public static string GetPickedObjectType()
{
GameObjectWrapper pickedObjectWrapper = null;
foreach (GameObjectWrapper wrapper in wrappers)
{
if (wrapper.instanceSceneName == "PlayerInventory")
{
pickedObjectWrapper = wrapper;
break;
}
}
if (pickedObjectWrapper == sheepWrapper)
{
return("sheep");
}
else if (pickedObjectWrapper == fenceWrapper)
{
return("fence");
}
else if (pickedObjectWrapper == haystackWrapper)
{
return("haystack");
}
return(null);
}
private void Awake()
{
if (!loaded)
{
if (sheepWrapper != null)
{
Destroy(sheepWrapper.gameObject);
}
if (fenceWrapper != null)
{
Destroy(fenceWrapper.gameObject);
}
if (haystackWrapper != null)
{
Destroy(haystackWrapper.gameObject);
}
sheepWrapper = InstantiateGlobal(sheepPrefab, "DreamScene");
fenceWrapper = InstantiateGlobal(fencePrefab, "DreamScene");
haystackWrapper = InstantiateGlobal(haystackPrefab, "CliffDreamScene");
wrappers = new List <GameObjectWrapper> {
sheepWrapper,
fenceWrapper,
haystackWrapper,
};
loaded = true;
}
SceneManager.LoadScene("HUDScene", LoadSceneMode.Additive);
}
public void GameObject()
{
var obj = new GameObject("obj");
var wrapper = new GameObjectWrapper(obj);
Assert.AreSame(obj, wrapper.GameObject);
}
public bool CalculateDisplacement(out IGameObject pickedObject, out Vector3 displacement)
{
bool show = false;
pickedObject = null;
displacement = Vector3.zero;
// Send a ray from the center of the screen to the object
Ray ray = Camera.main.ViewportPointToRay(new Vector3(0.5f, 0.5f));
RaycastHit hit = new RaycastHit();
// Only raycast when player has either a full block or is in delete mode.
if (finger.Team.IsMine &&
(Player.Player.LocalPlayer.HasFullBlock || finger.Mode == CubeFingerMode.Delete) &&
Physics.Raycast(ray, out hit, MAX_PICKING_DISTANCE))
{
Transform picked = hit.transform;
if (picked.parent.name == finger.Team.Target)
{
pickedObject = new GameObjectWrapper(picked.gameObject);
if (finger.Mode == CubeFingerMode.Build)
{
displacement = calculateSide(pickedObject, hit);
}
show = true;
}
}
return(show);
}
public override void WriteJson(JsonWriter writer, GameObject value, JsonSerializer serializer)
{
var gameObjectJson = serializer.GetJsonString(value, this, new GameObjectContractResolver());
var gameObjectWrapper = new GameObjectWrapper(gameObjectJson, value.transform);
serializer.Serialize(writer, gameObjectWrapper, typeof(GameObjectWrapper));
}
public object Call(Interpreter interpreter, Token token, List <object> arguments)
{
GameObjectWrapper goLeft = (GameObjectWrapper)arguments[0];
GameObjectWrapper goRight = (GameObjectWrapper)arguments[1];
return(System.Object.ReferenceEquals(goLeft.GetSelf(), goRight.GetSelf()));
}
public void GameObjectHandle()
{
var obj = new GameObject("obj");
var handle = ScriptableObject.CreateInstance <GameObjectHandle>();
var wrapper = new GameObjectWrapper(handle);
handle.GameObject = obj;
Assert.AreSame(obj, wrapper.GameObject);
}
internal override bool matches(GameObjectWrapper gameObjectWrapper)
{
for (int i = 0; i < _componentTypeNames.Length; ++i)
{
if (gameObjectWrapper._componentTypeNames.Contains(_componentTypeNames[i]) == true)
{
return(false);
}
}
return(true);
}
public void GameObjectHandleConflict()
{
var obj = new GameObject("obj");
var handle = ScriptableObject.CreateInstance <GameObjectHandle>();
var wrapper = new GameObjectWrapper(obj, handle);
handle.GameObject = obj;
Assert.Throws <System.ArgumentException>(() => {
var _ = wrapper.GameObject;
});
}
private GameObjectWrapper InstantiateGlobal(GameObject prefab, string instanceSceneName)
{
GameObject globalGameObject = Instantiate(prefab);
globalGameObject.SetActive(false);
DontDestroyOnLoad(globalGameObject);
GameObjectWrapper wrapper = new GameObjectWrapper {
gameObject = globalGameObject,
instanceSceneName = instanceSceneName,
};
return(wrapper);
}
public static void PickObject(GameObject pickedGameObject)
{
GameObjectWrapper pickedGameObjectWrapper = null;
foreach (GameObjectWrapper wrapper in wrappers)
{
if (wrapper.gameObject == pickedGameObject)
{
pickedGameObjectWrapper = wrapper;
break;
}
}
pickedGameObjectWrapper.instanceSceneName = "PlayerInventory";
}
/// <summary>
/// Gets all of the game objects of the specified type.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns>GameObjectWrapper<T>.</returns>
public static GameObjectWrapper <T> Get <T>() where T : GameObject, new()
{
var type = typeof(T);
var found = new GameObjectWrapper <T>();
foreach (var key in gameObjects.Keys)
{
if (type.IsAssignableFrom(key))
{
found.AddRange(gameObjects[key].Values.Where(o => o.IsValid <T>()).ToList().ConvertAll(o => (T)o));
}
}
return(found);
}
public static void DropObject(GameObject droppedGameObject)
{
GameObjectWrapper droppedGameObjectWrapper = null;
foreach (GameObjectWrapper wrapper in wrappers)
{
if (wrapper.gameObject == droppedGameObject)
{
droppedGameObjectWrapper = wrapper;
break;
}
}
droppedGameObjectWrapper.instanceSceneName = SceneManager.GetActiveScene().name;
}
internal override bool matches(GameObjectWrapper gameObjectWrapper)
{
// Prevent user error if a GameObject is destroyed while it is still binded. It's a mistake, the user has to unbind game objects before destroying them.
if (gameObjectWrapper._gameObject != null)
{
UnityEngine.GameObject gameObject = gameObjectWrapper._gameObject;
for (int i = 0; i < _properties.Length; ++i)
{
if (hasProperty(gameObject, _properties[i]) == true)
{
return(true);
}
}
}
return(false);
}
internal override bool matches(GameObjectWrapper gameObjectWrapper)
{
// Prevent user error if a GameObject is destroyed while it is still binded. It's a mistake, the user has to unbind game objects before destroying them.
if (gameObjectWrapper._gameObject != null)
{
string gameObjectTag = gameObjectWrapper._gameObject.tag;
for (int i = 0; i < _tags.Length; ++i)
{
if (gameObjectTag == _tags [i])
{
return(true);
}
}
}
return(false);
}
public void GameObjectHandleConflictMessage()
{
var obj = new GameObject("obj");
var handle = ScriptableObject.CreateInstance <GameObjectHandle>();
var wrapper = new GameObjectWrapper(obj, handle);
handle.GameObject = obj;
try {
var _ = wrapper.GameObject;
} catch (System.ArgumentException e) {
string msg =
"GameObjectWrapper has gameObject and handler assigned, " +
"only assign one";
Assert.AreEqual(msg, e.Message);
}
}
public DestroyCallable(GameObjectWrapper self)
{
this.self = self;
}
// Update is called once per frame
void Update()
{
if (cubes.Count <= 200)
{
xlist = new List <GameObjectWrapper>();
ylist = new List <GameObjectWrapper>();
zlist = new List <GameObjectWrapper>();
foreach (GameObject item in cubes)
{
GameObjectWrapper tempXMin = new GameObjectWrapper(item.renderer.bounds.min.x, true, item);
GameObjectWrapper tempXMax = new GameObjectWrapper(item.renderer.bounds.max.x, false, item);
xlist.Add(tempXMin);
xlist.Add(tempXMax);
GameObjectWrapper tempYMin = new GameObjectWrapper(item.renderer.bounds.min.y, true, item);
GameObjectWrapper tempYMax = new GameObjectWrapper(item.renderer.bounds.max.y, false, item);
ylist.Add(tempYMin);
ylist.Add(tempYMax);
GameObjectWrapper tempZMin = new GameObjectWrapper(item.renderer.bounds.min.z, true, item);
GameObjectWrapper tempZMax = new GameObjectWrapper(item.renderer.bounds.max.z, false, item);
zlist.Add(tempZMin);
zlist.Add(tempZMax);
item.renderer.material.color = Color.white;
}
}
activeCollisionsX = new List <GameObject>();
activeCollisionsY = new List <GameObject>();
activeCollisionsZ = new List <GameObject>();
currentCollisionsX = new List <GameObject>();
currentCollisionsY = new List <GameObject>();
currentCollisionsZ = new List <GameObject>();
xlist.Sort(delegate(GameObjectWrapper a, GameObjectWrapper b) { return(a.f.CompareTo(b.f)); });
ylist.Sort(delegate(GameObjectWrapper a, GameObjectWrapper b) { return(a.f.CompareTo(b.f)); });
zlist.Sort(delegate(GameObjectWrapper a, GameObjectWrapper b) { return(a.f.CompareTo(b.f)); });
foreach (GameObjectWrapper i in xlist)
{
// i is a starting point, and active collisions doesn't already contain the gameobject we're looking at
if (activeCollisionsX.Contains(i.item) == false)
{
activeCollisionsX.Add(i.item);
// if we've got more than 2 things colliding on x axis
//Debug.Log(activeCollisionsX.Count);
if (activeCollisionsX.Count >= 2)
{
// add everything in active collisions if it already isnt there
foreach (GameObject item in activeCollisionsX)
{
if (currentCollisionsX.Contains(item) == false)
{
currentCollisionsX.Add(item);
}
}
}
}
else if (activeCollisionsX.Contains(i.item) == true)
{
activeCollisionsX.Remove(i.item);
}
}
foreach (GameObjectWrapper i in ylist)
{
// i is a starting point, and active collisions doesn't already contain the gameobject we're looking at
if (activeCollisionsY.Contains(i.item) == false)
{
activeCollisionsY.Add(i.item);
// if we've got more than 2 things colliding on x axis
//Debug.Log(activeCollisionsX.Count);
if (activeCollisionsY.Count >= 2)
{
// add everything in active collisions if it already isnt there
foreach (GameObject item in activeCollisionsY)
{
if (currentCollisionsX.Contains(item) == true)
{
if (currentCollisionsY.Contains(item) == false)
{
currentCollisionsY.Add(item);
}
}
}
}
}
else if (activeCollisionsY.Contains(i.item) == true)
{
activeCollisionsY.Remove(i.item);
}
}
foreach (GameObjectWrapper i in zlist)
{
// i is a starting point, and active collisions doesn't already contain the gameobject we're looking at
if (activeCollisionsZ.Contains(i.item) == false)
{
activeCollisionsZ.Add(i.item);
// if we've got more than 2 things colliding on x axis
//Debug.Log(activeCollisionsX.Count);
if (activeCollisionsZ.Count >= 2)
{
// add everything in active collisions if it already isnt there
foreach (GameObject item in activeCollisionsZ)
{
if (currentCollisionsX.Contains(item) == true)
{
if (currentCollisionsY.Contains(item) == true)
{
if (currentCollisionsZ.Contains(item) == false)
{
currentCollisionsZ.Add(item);
}
}
}
}
}
}
else if (activeCollisionsZ.Contains(i.item) == true)
{
activeCollisionsZ.Remove(i.item);
}
}
List <GameObject> totalCollisions = new List <GameObject>();
foreach (GameObject item1 in currentCollisionsZ)
{
foreach (GameObject item2 in currentCollisionsZ)
{
if (item1.GetInstanceID() != item2.GetInstanceID())
{
if (isColliding(item1, item2))
{
if (totalCollisions.Contains(item1) == false)
{
totalCollisions.Add(item1);
}
}
}
}
}
foreach (GameObject item in cubes)
{
if (totalCollisions.Contains(item))
{
if (item.tag == "Player")
{
item.renderer.material.color = Color.red;
}
else
{
item.renderer.material.color = Color.black;
}
}
else
{
if (item.tag == "Player")
{
item.renderer.material.color = Color.cyan;
}
else
{
item.renderer.material.color = Color.white;
}
}
}
}
public static C AssertComponent <C>(this GameObjectWrapper handle) => handle.GameObject.AssertComponent <C>();
internal abstract bool matches(GameObjectWrapper gameObjectWrapper);
private void Start()
{
//this.gameObject.AddComponent<Rideable>();
GameObjectWrapper gameObjectWrapper = this.GetComponent <SpawnableObjectScript>().wrapper;
if (gameObjectWrapper == null)
{
return;
}
this.gameObject.name = this.gameObject.name + ".ID : " + FreightCartUnity.MinecartNumber;
++FreightCartUnity.MinecartNumber;
this.mHoverLight = this.transform.Find("HoverLight").GetComponent <Light>();
if (this.mHoverLight == null)
{
Debug.LogError("Error, Minecart had no hover light?");
}
this.mob = gameObjectWrapper.mPayload as FreightCartMob;
this.Body = Extensions.Search(this.transform, "Minecart GFX").gameObject;
this.mnHealth = -999999;
this.mRenderer = this.GetComponentsInChildren <Renderer>();
this.mbRenderer = true;
this.mbDoorRenderer = true;
this.LoadParticles = Extensions.Search(this.transform, "Loading Particles").GetComponent <ParticleSystem>();
this.LoadParticlesDust = Extensions.Search(this.transform, "Loading Particles Dust").GetComponent <ParticleSystem>();
this.Door_L = Extensions.Search(this.transform, "Minecart Door L").gameObject;
this.Door_R = Extensions.Search(this.transform, "Minecart Door R").gameObject;
if (DateTime.Now.Month != 4 || DateTime.Now.Day > 1)
{
Extensions.Search(this.transform, "AprilFool").gameObject.SetActive(false);
}
this.mAudio = this.GetComponent <AudioSource>();
Material material = (Material)null;
if (this.mob.mObjectType == SpawnableObjectEnum.Minecart_T1)
{
if ((UnityEngine.Object)Minecart_Unity.T1_Mat == (UnityEngine.Object)null)
{
Minecart_Unity.T1_Mat = Resources.Load("DynamicTextures/Minecart_dif") as Material;
}
material = Minecart_Unity.T1_Mat;
}
if (this.mob.mObjectType == SpawnableObjectEnum.Minecart_T2)
{
if ((UnityEngine.Object)Minecart_Unity.T2_Mat == (UnityEngine.Object)null)
{
Minecart_Unity.T2_Mat = Resources.Load("DynamicTextures/Minecart_dif T2") as Material;
}
material = Minecart_Unity.T2_Mat;
}
if (this.mob.mObjectType == SpawnableObjectEnum.Minecart_T3)
{
if ((UnityEngine.Object)Minecart_Unity.T3_Mat == (UnityEngine.Object)null)
{
Minecart_Unity.T3_Mat = Resources.Load("DynamicTextures/Minecart_dif T3") as Material;
}
material = Minecart_Unity.T3_Mat;
}
if (this.mob.mObjectType == SpawnableObjectEnum.Minecart_T4)
{
if ((UnityEngine.Object)Minecart_Unity.T4_Mat == (UnityEngine.Object)null)
{
Minecart_Unity.T4_Mat = Resources.Load("DynamicTextures/Minecart_dif T4") as Material;
}
material = Minecart_Unity.T4_Mat;
}
if (material != null)
{
this.Door_L.GetComponent <Renderer>().material = material;
this.Door_R.GetComponent <Renderer>().material = material;
this.Body.GetComponent <Renderer>().material = material;
}
this.mCurrentPos = this.transform.position;
this.mMPB = new MaterialPropertyBlock();
if (this.mHoverLight != null && this.mob.IsOreFreighter)
{
this.mMPB.SetColor("_GlowColor", Color.blue);
}
}
int CompareGameObjects(GameObjectWrapper a, GameObjectWrapper b)
{
return(a.f.CompareTo(b.f));
}
