void Interact()
{
RaycastHit hit;
if (Physics.Raycast(cam.transform.position, cam.transform.forward, out hit, checkingDistance,
maskWithoutPlayer))
{
if (hit.collider.GetComponentInParent <ContainerController>())
{
ContainerController controller = hit.collider.GetComponentInParent <ContainerController>();
controller.PickUp();
controller.transform.parent = handheldObjectTransform;
controller.transform.localPosition = Vector3.zero;
controller.transform.localRotation = Quaternion.Euler(0, 0, 0);
heldObject = controller.gameObject;
}
else if (hit.collider.GetComponentInParent <InteractableObject>())
{
if (hit.collider.GetComponentInParent <PressablePlate>() && hit.collider.GetComponentInParent <PressablePlate>().hasContainer)
{
ContainerController controller = hit.collider.GetComponentInChildren <ContainerController>();
hit.collider.GetComponentInParent <InteractableObject>().Activate(false);
controller.transform.parent = handheldObjectTransform;
controller.transform.localPosition = Vector3.zero;
controller.transform.localRotation = Quaternion.Euler(0, 0, 0);
heldObject = controller.gameObject;
return;
}
hit.collider.GetComponentInParent <InteractableObject>().Activate(false);
}
}
}
public void SetActive(bool active)
{
if (this.active == active)
{
return;
}
//switch modes
this.active = active;
if (this.active) //TODO: (1) handle no carry object
{
ContainerController containerController = gameController.GetPlayerCarryGameObject().GetComponent <ContainerController>();
List <object> contents = containerController.GetContents();
for (int i = 0; i < (int)(double)containerController.realCapacity; i++)
{
GameObject go = GameObject.Instantiate(slotPrefab, gameObject.transform);
if (i < contents.Count)
{
go.GetComponent <Image>().sprite = ((Toy.GameObjectWrapper)contents[i]).GetSelf().GetComponent <SpriteRenderer>().sprite;
}
}
}
else
{
foreach (Transform child in transform)
{
GameObject.Destroy(child.gameObject);
}
}
}
// Update is called once per frame
void Update()
{
GameObject activeBlocks = GameObject.FindWithTag("ActiveBlock");
if (isInputReleased())
{
if (activeBlocks != null)
{
ContainerController container = activeBlocks.GetComponent <ContainerController>();
if (container != null)
{
int moveToColumn = columns.CheckPointColumnIndex(Input.mousePosition);
if (moveToColumn != -1)
{
container.AttemptMoveToColumn(moveToColumn);
}
}
}
}
if (Input.GetMouseButtonUp(1))
{
ContainerController container = activeBlocks.GetComponent <ContainerController>();
container.SwapColors();
}
if (Input.GetKeyUp("space"))
{
activeBlocks.GetComponent <ContainerController>().setMoveAtTime(0.00001f);
}
}
private void OnItemSplit(Item item, int amount)
{
if (item.parentItem != null)
{
return;
}
var container = ContainerController.Find(item.parent);
if (container == null)
{
return;
}
PrintDebug($"OnItemSplit: {item.info.shortname} ({item.amount}x, slot {item.position}); {amount}x");
var main = container.Container.GetSlot(0);
if (main == null)
{
PrintDebug("Main item is null");
return;
}
NextFrame(() =>
{
if (main.uid != item.uid) // Ignore main item because it's amount will be changed
{
main.amount -= amount;
}
container.UpdateContent(0);
});
}
private void OnItemAddedToContainer(ItemContainer itemContainer, Item item)
{
if (item.parentItem != null)
{
return;
}
var player = itemContainer.GetOwnerPlayer();
var container = ContainerController.Find(itemContainer);
if (container == null || player != null)
{
return;
}
PrintDebug($"OnItemAddedToContainer: {item.info.shortname} (slot {item.position})");
if (itemContainer.itemList.Count != 1)
{
item.position = -1;
item.parent.itemList.Remove(item);
item.parent = null;
container.GiveItemBack();
container.Clear();
item.parent = container.Container;
item.parent.itemList.Add(item);
}
item.position = 0;
container.StoreContent(item);
container.UpdateContent(0);
}
private void createContainer(object sender, EventArgs e)
{
ControllerInterface node = new ContainerController(new EvilTool.Model.Container());
TreeNode added = tree.Nodes.Add(node.getName());
added.Tag = node;
}
private static float MIN_FINGER_TO_PALM_DISTANCE = 0.040f;//0.045f;
void Start()
{
this.CurrentGraspState = GraspState.RELEASED;
this.ActiveObject = null;
this.ObjectMaxAngularVelocity = 0.0f;
this.RotationFromPalm = Quaternion.identity;
this.CurrentGraspCenter = Vector3.zero;
this.SmoothedGraspPosition = Vector3.zero;
this.GraspOffset = Vector3.zero;
this.PalmRotation = Quaternion.identity;
this.ReleaseStrengthCurve = new AnimationCurve();
this.ReleaseStrengthCurve.AddKey(new Keyframe(0.0f, 1.0f));
this.ReleaseStrengthCurve.AddKey(new Keyframe(1.001355f, -0.0007067919f));
GameObject container = GameObject.FindGameObjectWithTag("Container");
if (container != null)
{
ContainerController containerController = container.GetComponent <ContainerController>();
if (containerController != null)
{
//containerController.ObjectWasReleased += new ContainerController.ObjectWasReleasedHandler(this.checkRelease);
containerController.ObjectWasReleased += (this.checkRelease);
}
}
}
public static void Load()
{
bool canceled = false;
int containerId = SelectContainerId(out canceled);
if (canceled)
{
return;
}
int transportId = TransportViewController.SelectTransportId(out canceled);
if (canceled)
{
return;
}
try
{
var cc = new ContainerController();
var container = cc.GetById(containerId);
if (container.TransportId.HasValue)
{
throw new HprException("Container must be unloaded first");
}
cc.Move(containerId, transportId);
Console.WriteLine($"Successfully loaded");
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public Startup()
{
_userDb = new UsersLibrary();
_run = true;
_userAuth = false;
_containerController = new ContainerController();
_ChallengesCOntroller = new ChallengesController();
}
private void OnPlayerConnected(BasePlayer player)
{
if (ContainerController.FindIndex(player) != -1)
{
return;
}
_controllers.Add(new ContainerController(player)); // lol
}
private void SkinsClose(BasePlayer player)
{
if (player == null)
{
return;
}
ContainerController.Find(player)?.Close();
}
private static void DisplayContainerList(int?transportId)
{
BeginOutput();
PrintHeader("Container List");
var tc = new ContainerController();
var containers = tc.List(transportId);
PrintContainers(containers);
}
public override void Activate(bool forced)
{
if (hasContainer)
{
ContainerController controller = GetComponentInChildren <ContainerController>();
controller.PickUp();
hasContainer = false;
isActivated = false;
}
}
private void Start()
{
if (Instance != null && Instance != this)
{
Destroy(gameObject);
}
else
{
Instance = this;
}
}
void SpawnBlock()
{
if (currentIndex < pool.Length && (activeBlock == null || !activeBlock.getIsActive()))
{
activeBlock = pool[currentIndex];
activeBlock.gameObject.SetActive(true);
activeBlock.setMoveAtTime(moveAtTime);
activeBlock.ActivateBlocks();
currentIndex++;
}
}
private void OnPlayerLootEnd(PlayerLoot loot)
{
var player = loot.gameObject.GetComponent <BasePlayer>();
if (player != loot.entitySource)
{
return;
}
PrintDebug("OnLootEntityEnd: Closing container");
ContainerController.Find(player)?.Close();
}
private void OnPlayerDisconnected(BasePlayer player)
{
var index = ContainerController.FindIndex(player);
if (index == -1)
{
return;
}
_controllers[index].Destroy();
_controllers.RemoveAt(index);
}
public void RowSelected(UITableView tableView, NSIndexPath indexPath)
{
tableView.DeselectRow(indexPath, true);
MenuItem item = Items [indexPath.Row];
Action action = item.Action;
if (action != null)
{
action();
}
ContainerController.HideMenu();
}
private object CanMoveItemTo(ContainerController controller, Item item, int slot, int amount)
{
var targetItem = controller?.Container?.GetSlot(slot);
if (targetItem != null)
{
// Give target item back
controller.GiveItemBack(targetItem);
controller.Clear();
}
return(null);
}
void InitialisePool()
{
pool = new ContainerController[poolCount];
for (int i = 0; i < poolCount; i++)
{
GameObject newObject = (GameObject)Instantiate(objectType, new Vector3(0, 0, 0), Quaternion.identity);
newObject.transform.SetParent(GetComponent <Transform>(), false);
newObject.gameObject.SetActive(false);
ContainerController container = newObject.GetComponent <ContainerController>();
container.setBlockManager(this);
pool[i] = container;
}
}
void OnDestroy()
{
GameObject container = GameObject.FindGameObjectWithTag("Container");
if (container != null)
{
ContainerController containerController = container.GetComponent <ContainerController>();
if (containerController != null)
{
containerController.ObjectWasReleased -= (this.checkRelease);
}
}
this.OnRelease();
}
void Awake()
{
this.HandControllerObject = GameObject.FindWithTag("LeapController");
this.HandControllerReference = this.HandControllerObject.GetComponent <ExperimentHandController>();
GameObject rangeCheckContainer = GameObject.FindGameObjectWithTag("RangeCheck");
this.RangeCheck = rangeCheckContainer.GetComponent <EffectorRangeCheck>();
this.RangeCheck.ObjectLeftBounds += this.rangeCheckHandler;
GameObject posecontrollerContainer = GameObject.FindGameObjectWithTag("PoseController");
this.HandPoseController = posecontrollerContainer.GetComponent <PoseController>();
// register container controller
GameObject container = GameObject.FindGameObjectWithTag("Container");
if (container != null)
{
ContainerController containerController = container.GetComponent <ContainerController>();
if (containerController != null)
{
//containerController.ObjectWasReleased += new ContainerController.ObjectWasReleasedHandler(this.checkTargetPosition);
containerController.ObjectWasReleased += this.checkTargetPosition;
containerController.ObjectWasDestroyed += this.checkTargetDestruction;
}
}
this.Target.SetActive(true);
this.Target.transform.position = new Vector3(0, -100, 100);
this.Target.GetComponent <Rigidbody>().isKinematic = true;
this.FixationObject = GameObject.FindGameObjectWithTag("FixationObject");
this.TrialUpdateDelegate = delegate() { this.TrialUpdate(); };
//setup trial control
this.CurrentTrialState = new TrainingStateObject();
this.CurrentTrialState.TrialState = TrainingStates.STARTUP;
// register listeners
SliderFocusHandler.SliderEvent += this.handleSlider;
CheckMarkFocusHandler.ToggleEvent += this.handleToggle;
if (GraspTrainingController.Verbose)
{
UnityEngine.Debug.Log("done with awaking...");
}
this.OffsetController.ApplyDrift = false;
this.TrainingUI.SetActive(false);
}
void Update()
{
if (Input.GetMouseButtonDown(0) && isTurn)
{
var hit = Physics2D.Raycast(Camera.main.ScreenToWorldPoint(Input.mousePosition), Vector2.zero);
if (hit.collider != null)
{
ContainerController containerController = hit.transform.gameObject.GetComponent <ContainerController>();
lastMoveId = containerController.id;
containerController.SetState(localPlayerSelection, localPlayerSprite);
isTurn = false;
}
}
}
/// <summary>
/// Adds a few default containers to the db if it's empty
/// </summary>
static void AddDefaultContainers()
{
var cc = new ContainerController();
if (cc.GetCount() > 0)
{
return;
}
cc.AddContainer("Container A");
cc.AddContainer("Container B");
cc.AddContainer("Container C");
cc.AddContainer("Container D");
cc.AddContainer("Container E");
}
private void SpawnContainer()
{
if (fillableContainer)
{
return;
}
fillableContainer = BoxCreator.Instance.Create <ContainerData>(
containerPos.position,
new Vector3(
Random.Range(2.5f, 3f),
Random.Range(2f, 3f),
Random.Range(2f, 3f)
),
null
).GetComponent <ContainerController>();
}
private object CanLootPlayer(BasePlayer looter, Object target)
{
if (looter != target)
{
return(null);
}
var container = ContainerController.Find(looter);
if (container == null || !container.IsOpened)
{
return(null);
}
return(true);
}
public GameObject SetPlayerCarryGameObject(GameObject go)
{
ContainerController controller = go.GetComponent <ContainerController>();
if (controller == null)
{
ShowError("Can't carry that item: " + go.name);
return(null);
}
//TODO: (1) must be a carry type
controller.positionX = Int32.MaxValue;
controller.positionY = Int32.MaxValue;
return(playerCarryObject = go);
}
void OnDestroy()
{
// unregister container controller
GameObject container = GameObject.FindGameObjectWithTag("Container");
if (container != null)
{
ContainerController containerController = container.GetComponent <ContainerController>();
if (containerController != null)
{
containerController.ObjectWasReleased -= this.checkTargetPosition;
containerController.ObjectWasDestroyed -= this.checkTargetDestruction;
}
}
this.RangeCheck.ObjectLeftBounds -= this.rangeCheckHandler;
}
private void createLayer(object sender, EventArgs e)
{
TreeNode selected = tree.SelectedNode;
if (selected.Tag is ContainerController)
{
// model
ContainerController parent = (ContainerController)selected.Tag;
LayerController node = new LayerController(new Layer());
parent.add(node);
// ui
TreeNode added = selected.Nodes.Add(node.getName());
added.Tag = node;
selected.Expand();
}
}
private object CanMoveItem(Item item, PlayerInventory playerLoot, uint targetContainerId, int slot, int amount)
{
PrintDebug(
$"Move {item.info.shortname} ({item.amount}) from {item.parent?.uid ?? 0} to {targetContainerId} in {slot} ({amount})");
if (item.parent?.uid == targetContainerId)
{
PrintDebug("Move Ignoring same containers");
return(null);
}
var containerFrom = ContainerController.Find(item.parent);
var containerTo = ContainerController.Find(targetContainerId);
return(CanMoveItemFrom(containerFrom, item, playerLoot, slot, amount) ??
CanMoveItemTo(containerTo, item, playerLoot, slot, amount));
}
