public void GetReceptacleByNameTest2()
{
string name = "InvalidReceptacle";
Receptacle actual = context.GetReceptacleByName(name);
Assert.IsNull(actual);
}
void CheckForClearAndDelete(Receptacle r, int index, ref int deletedPivotIndex)
{
EditorGUILayout.BeginVertical();
Rect deleteArea = GUILayoutUtility.GetRect(
100.0f,
25.0f);
GUI.color = Color.Lerp(Color.grey, Color.yellow, 0.5f);
if (GUI.Button(deleteArea, "Delete pivot"))
{
if (EditorUtility.DisplayDialog("Delete pivot", "Are you sure you want to delete pivot?", "Yes", "Cancel"))
{
deletedPivotIndex = index;
}
}
Rect removeArea = GUILayoutUtility.GetRect(
100.0f,
25.0f);
if (r.Pivots[index].childCount > 0)
{
GUI.color = Color.white;
}
else
{
GUI.color = Color.grey;
}
if (GUI.Button(removeArea, "Clear pivot") && r.Pivots[index].transform.childCount > 0)
{
Transform item = r.Pivots[index].GetChild(0);
SimUtil.TakeItem(item.GetComponent <SimObj>());
}
EditorGUILayout.EndVertical();
}
/// <summary>
/// Conecta uma faceta a um receptáculo.
/// </summary>
/// <param name="receptacle">
/// O nome do receptáculo que se deseja conectar.
/// </param>
/// <param name="obj">
/// A referência para a faceta que se deseja conectar.
/// </param>
/// <exception cref="InvalidName">
/// Caso o nome do receptáculo seja inválido.
/// </exception>
/// <exception cref="InvalidConnection">
/// Caso a conexão não possa ser estabelecida, este erro pode acontecer
/// caso o <c>obj</c> não implemente a interface do receptáculo.
/// </exception>
/// <exception cref="AlreadyConnected">
/// Caso a faceta já esteja conectada.
/// </exception>
/// <exception cref="ExceededConnectionLimit">
/// Caso o número de conexões tenha excedido o limite configurado.
/// </exception>
public int connect(string receptacle, MarshalByRefObject obj)
{
IDictionary <string, Receptacle> receptacles =
context.GetReceptacles();
if (!receptacles.ContainsKey(receptacle))
{
throw new InvalidName {
name = receptacle
}
}
;
Receptacle rec = receptacles[receptacle];
if ((!rec.IsMultiple) &&
(rec.GetConnectionsSize() > 0))
{
throw new AlreadyConnected();
}
if (!IiopNetUtil.CheckInterface(obj, rec.InterfaceName))
{
throw new InvalidConnection();
}
int id = rec.AddConnections(obj);
logger.InfoFormat("Conexão {0} adicionada ao receptáculo '{1}'", id,
receptacle);
return(id);
}
public void IsMultipleTest()
{
Receptacle target = new Receptacle(name, interfaceName, isMultiple);
bool actual = target.IsMultiple;
Assert.AreEqual(isMultiple, actual);
}
public void InterfaceNameTest()
{
Receptacle target = new Receptacle(name, interfaceName, isMultiple);
string actual = target.InterfaceName;
Assert.AreEqual(interfaceName, actual);
}
//gets all VISIBILE SimObjs contained in a receptacle
//this does not TAKE any of these items
public static SimObj[] GetVisibleItemsFromReceptacle(Receptacle r, Camera agentCamera, Vector3 agentCameraPos, float maxDistance)
{
List <SimObj> items = new List <SimObj>();
RaycastHit hit;
foreach (Transform t in r.Pivots)
{
if (t.childCount > 0)
{
SimObj item = t.GetChild(0).GetComponent <SimObj> ();
//check whether the item is visible (center point only)
//since it's inside a receptacle, it will be on the invisible layer
if (CheckPointVisibility(item.CenterPoint, agentCamera))
{
item.VisibleNow = true;
items.Add(item);
}
else
{
item.VisibleNow = false;
}
}
}
return(items.ToArray());
}
//adds the item to a receptacle
//enabled the object, parents it under an empty pivot, then makes it invisible to raycasts
//returns false if there are no available pivots in the receptacle
public static bool AddItemToReceptacle(SimObj item, Receptacle r)
{
//make sure we're not doing something insane
if (item == null)
{
Debug.LogError("Can't add null item to receptacle");
return(false);
}
if (r == null)
{
Debug.LogError("Receptacle was null, not adding item");
return(false);
}
if (item.gameObject == r.gameObject)
{
Debug.LogError("Receptacle and item were same object, can't add item to itself");
return(false);
}
//make sure there's room in the recepticle
Transform emptyPivot = null;
if (!GetFirstEmptyReceptaclePivot(r, out emptyPivot))
{
//Debug.Log ("Receptacle is full");
return(false);
}
return(AddItemToReceptaclePivot(item, emptyPivot));
}
//searches for a SimObj item under a receptacle by ID
//this does not TAKE the item, it just searches for it
public static bool FindItemFromReceptacleByID(string itemID, Receptacle r, out SimObj item)
{
item = null;
//make sure we're not doing something insane
if (r == null)
{
Debug.LogError("Receptacle was null, not searching for item");
return(false);
}
if (!IsUniqueIDValid(itemID))
{
Debug.LogError("itemID " + itemID.ToString() + " is NOT valid, not searching for item");
return(false);
}
SimObj checkItem = null;
for (int i = 0; i < r.Pivots.Length; i++)
{
if (r.Pivots [i].childCount > 0)
{
checkItem = r.Pivots [i].GetChild(0).GetComponent <SimObj> ();
if (checkItem != null && checkItem.UniqueID == itemID)
{
//if the item under the pivot is a SimObj with the right id
//we've found what we're after
item = checkItem;
return(true);
}
}
}
//couldn't find it!
return(false);
}
void CheckForDragDropColliders(Receptacle r)
{
Event evt = Event.current;
Rect dropArea = GUILayoutUtility.GetRect(
100.0f,
100.0f);
GUI.Box(dropArea, "Drag-drop visibility collider here", EditorStyles.helpBox);
switch (evt.type)
{
case EventType.DragUpdated:
case EventType.DragPerform:
if (!dropArea.Contains(evt.mousePosition))
{
return;
}
DragAndDrop.visualMode = DragAndDropVisualMode.Generic;
if (evt.type == EventType.DragPerform)
{
DragAndDrop.AcceptDrag();
foreach (UnityEngine.Object draggedItem in DragAndDrop.objectReferences)
{
TryToSetVisibilityCollider(r, draggedItem);
}
}
break;
}
}
void CheckForDragDropPivots(Receptacle r)
{
Event evt = Event.current;
EditorGUILayout.LabelField("");
Rect dropArea = GUILayoutUtility.GetRect(0.0f, 35.0f, GUILayout.ExpandWidth(true));
GUI.Box(dropArea, "Drag-drop transforms here to add pivots", EditorStyles.helpBox);
switch (evt.type)
{
case EventType.DragUpdated:
case EventType.DragPerform:
if (!dropArea.Contains(evt.mousePosition))
{
return;
}
DragAndDrop.visualMode = DragAndDropVisualMode.Generic;
if (evt.type == EventType.DragPerform)
{
DragAndDrop.AcceptDrag();
foreach (UnityEngine.Object draggedTransform in DragAndDrop.objectReferences)
{
TryToAddPivot(draggedTransform, r);
}
}
break;
}
}
public void ReceptacleReceivedIngredient(Receptacle recep)
{
playerSequence.Add(new PlayerIteration()
{
receptacle = recep, isGoodanswer = false
});
var index = playerSequence.Count - 1;
if (recep.IsIngredientTag(currentSequence[index].simonIngredient.tag) && recep == currentSequence[index].receptacle)
{
playerSequence[index].isGoodanswer = true;
}
if (playerSequence[index].isGoodanswer)
{
if (currentSequence.Count == playerSequence.Count)
{
completion = 1.0f;
}
else
{
completion += 1.0f / currentSequence.Count;
}
Completion.Invoke(completion);
}
if (currentSequence.Count == playerSequence.Count)
{
StartCoroutine(WaitBeforeCheckPlayerSequence());
}
}
//searches for a SimObj item under a receptacle by ID
//this does not TAKE the item, it just searches for it
public static bool FindItemFromReceptacleByType(SimObjType itemType, Receptacle r, out SimObj item)
{
item = null;
//make sure we're not doing something insane
if (r == null)
{
Debug.LogError("Receptacle was null, not searching for item");
return(false);
}
if (itemType == SimObjType.Undefined)
{
Debug.LogError("Can't search for type UNDEFINED, not searching for item");
return(false);
}
SimObj checkItem = null;
for (int i = 0; i < r.Pivots.Length; i++)
{
if (r.Pivots [i].childCount > 0)
{
checkItem = r.Pivots [i].GetChild(0).GetComponent <SimObj> ();
if (checkItem != null && checkItem.Type == itemType)
{
//if the item under the pivot is a SimObj of the right type
//we've found what we're after
item = checkItem;
return(true);
}
}
}
//couldn't find it!
return(false);
}
public void GetConnectionsSizeTest()
{
Receptacle target = new Receptacle(name, interfaceName, isMultiple);
int actual;
int expected;
for (int i = 0; i < connections.Count; i++)
{
target.AddConnections(connections[i]);
actual = target.GetConnectionsSize();
expected = i + 1;
Assert.AreEqual(expected, actual);
}
int id = target.AddConnections(connections[0]);
expected = connections.Count + 1;
actual = target.GetConnectionsSize();
Assert.AreEqual(expected, actual);
target.RemoveConnetions(id);
expected = connections.Count;
actual = target.GetConnectionsSize();
Assert.AreEqual(expected, actual);
}
public void SetAllPivotsToUp()
{
Cabinet[] cabinets = GameObject.FindObjectsOfType <Cabinet>();
foreach (Cabinet cabinet in cabinets)
{
if (cabinet.ParentObj != null)
{
Receptacle r = cabinet.ParentObj.GetComponent <Receptacle>();
Transform pivot = r.Pivots[0];
Transform tempParent = pivot.parent;
Transform child = null;
if (pivot.childCount > 0)
{
child = pivot.GetChild(0);
child.parent = null;
}
pivot.parent = null;
pivot.up = Vector3.up;
pivot.localScale = Vector3.one;
if (child != null)
{
child.parent = pivot;
}
pivot.parent = tempParent;
}
}
}
public bool IsLastReceptacle(Receptacle recep)
{
if (playerSequence.Last().receptacle == recep)
{
return(true);
}
return(false);
}
//Click on a note which is in a receptacle and holding in the same time a note. Swap notes.
public void SwapNotes(NoteObject note)
{
NoteReceptacle tmp = Receptacle;
Receptacle.SwapNote(note);
TryGrab(null);
tmp.gameObject.layer = LayerMask.NameToLayer("GvrCannotGrab");
}
public void RemoveConnetionsTest3()
{
Receptacle target = new Receptacle(name, interfaceName, isMultiple);
int id = Int32.MaxValue;
bool actual = target.RemoveConnetions(id);
Assert.AreEqual(false, actual);
}
// add receptacle to database
// requires receptacle object
// returns boolean
public Boolean AddReceptacle(Receptacle pin)
{
if (GetReceptacle(pin.ID) == null)
{
conn.Insert(pin);
return(true);
}
return(false);
}
public void RemoveConnetionsTest()
{
Receptacle target = new Receptacle(name, interfaceName, isMultiple);
MarshalByRefObject connection = connections[0];
int id = target.AddConnections(connection);
bool actual = target.RemoveConnetions(id);
Assert.AreEqual(true, actual);
}
// udpates receptacle in database
// requires receptacle object
// returns receptacle ID
public int UpdateReceptacle(Receptacle rec)
{
if (GetReceptacle(rec.ID) != null)
{
conn.Update(rec);
return(rec.ID);
}
AddReceptacle(rec);
return(rec.ID);
}
public void GetDescriptionTest1()
{
Receptacle target = new Receptacle(name, interfaceName, isMultiple);
ReceptacleDescription expected = new ReceptacleDescription(name, interfaceName, isMultiple, new ConnectionDescription[0]);
ReceptacleDescription actual = target.GetDescription();
Assert.AreEqual(expected.name, actual.name);
Assert.AreEqual(expected.interface_name, actual.interface_name);
Assert.AreEqual(expected.is_multiplex, actual.is_multiplex);
}
//tries to get a receptacle from a collider, returns false if none found
public static bool GetReceptacleFromCollider(Collider c, out Receptacle r)
{
r = null;
if (c.attachedRigidbody == null)
{
//all sim objs must have a kinematic rigidbody
return(false);
}
r = c.attachedRigidbody.GetComponent <Receptacle> ();
return(r != null);
}
public void pong()
{
Console.WriteLine("[Executando o método pong no componente Pong]");
Receptacle receptacle = context.GetReceptacles()["PongRec"];
foreach (ConnectionDescription connection in receptacle.GetConnections())
{
PingPongServer pingPongServer = connection.objref as PingPongServer;
pingPongServer.pong();
}
}
public void GetReceptacleByNameTest1()
{
string name = typeof(IComponent).Name;
string interfaceName = Repository.GetRepositoryID(typeof(IComponent));
Receptacle expected = new Receptacle(name, interfaceName, true);
context.AddReceptacle(name, interfaceName, true);
Receptacle actual = context.GetReceptacleByName(name);
Assert.AreEqual(expected, actual);
}
public void ReceptacleRemovedIngredient(Receptacle recep)
{
var index = playerSequence.FindIndex(r => r.receptacle == recep);
if (playerSequence[index].isGoodanswer)
{
completion -= 1.0f / currentSequence.Count;
Completion.Invoke(completion);
}
playerSequence.RemoveAt(index);
}
//gets all SimObjs contained in a receptacle
//this does not TAKE any of these items
public static SimObj[] GetItemsFromReceptacle(Receptacle r)
{
List <SimObj> items = new List <SimObj>();
foreach (Transform t in r.Pivots)
{
if (t.childCount > 0)
{
items.Add(t.GetChild(0).GetComponent <SimObj>());
}
}
return(items.ToArray());
}
public static bool GetFirstEmptyReceptaclePivot(Receptacle r, out Transform emptyPivot)
{
emptyPivot = null;
for (int i = 0; i < r.Pivots.Length; i++)
{
if (r.Pivots [i].childCount == 0)
{
emptyPivot = r.Pivots [i];
break;
}
}
return(emptyPivot != null);
}
public void RemoveReceptaclesTest()
{
ReceptacleInfomation recInfo = receptacleList[0];
Receptacle actual = context.GetReceptacleByName(recInfo.name);
Assert.IsNull(actual);
context.AddReceptacle(recInfo.name, recInfo.interfaceName, recInfo.isMultiple);
actual = context.GetReceptacleByName(recInfo.name);
Assert.IsNotNull(actual);
context.RemoveReceptacle(recInfo.name);
actual = context.GetReceptacleByName(recInfo.name);
Assert.IsNull(actual);
}
public void GetConnectionsTest()
{
Receptacle target = new Receptacle(name, interfaceName, isMultiple);
List <ConnectionDescription> expected = new List <ConnectionDescription>();
List <ConnectionDescription> actual = target.GetConnections();
Assert.AreEqual(expected.Count, actual.Count);
for (int i = 0; i < connections.Count; i++)
{
target.AddConnections(connections[i]);
}
actual = target.GetConnections();
Assert.AreEqual(connections.Count, actual.Count);
}
/// <summary>
/// Obtém as conexões existentes no receptáculo.
/// </summary>
/// <param name="receptacle">O nome do receptáculo.</param>
/// <returns>O conjunto de descritores de conexão.</returns>
/// <exception cref="InvalidName">Caso um nome seja inválido.</exception>
public ConnectionDescription[] getConnections(string receptacle)
{
IDictionary <string, Receptacle> receptacles = context.GetReceptacles();
if (!receptacles.ContainsKey(receptacle))
{
throw new InvalidName {
name = receptacle
}
}
;
Receptacle rec = receptacles[receptacle];
return(rec.GetConnections().ToArray());
}
