public FormNewBag(Document document, BagProperties bag)
: base(document, bag)
{
InitializeComponent();
if (DesignMode)
{
return;
}
// properties
if (null != bag)
{
uCtrlOuterDimensions.ValueX = bag.Length;
uCtrlOuterDimensions.ValueY = bag.Width;
uCtrlOuterDimensions.ValueZ = bag.Height;
uCtrlRadius.Value = bag.Radius;
uCtrlWeight.Value = bag.Weight;
uCtrlNetWeight.Value = bag.NetWeight;
cbColor.Color = bag.ColorFill;
}
else
{
uCtrlOuterDimensions.ValueX = UnitsManager.ConvertLengthFrom(400.0, UnitsManager.UnitSystem.UNIT_METRIC1);
uCtrlOuterDimensions.ValueY = UnitsManager.ConvertLengthFrom(300.0, UnitsManager.UnitSystem.UNIT_METRIC1);
uCtrlOuterDimensions.ValueZ = UnitsManager.ConvertLengthFrom(100.0, UnitsManager.UnitSystem.UNIT_METRIC1);
uCtrlRadius.Value = UnitsManager.ConvertLengthFrom(40.0, UnitsManager.UnitSystem.UNIT_METRIC1);
uCtrlWeight.Value = UnitsManager.ConvertMassFrom(1.0, UnitsManager.UnitSystem.UNIT_METRIC1);
uCtrlNetWeight.Value = OptDouble.Zero;
cbColor.Color = Color.Beige;
}
// units
UnitsManager.AdaptUnitLabels(this);
}
public void addBag(BagProperties bag)
{
if (bags == null)
{
bags = new List <BagProperties>();
}
bags.Add(bag);
}
public void moveConveyor(float movement, XRayMachine xRayMachine)
{
if (bagInspectState == BagHandler.BagInspectState.NOTHING)
{
float xrayScanRight = xRayMachine.scanRight;
float xrayScanLeft = xRayMachine.scanLeft;
List <GameObject> bags = Misc.FindShallowStartsWith("Bag_");
foreach (GameObject bag in bags)
{
BagProperties bagProperties = bag.GetComponent <BagProperties>();
if (bagProperties.isOnConveyor)
{
float bagNewXPos = bag.transform.position.x + movement;
GameObject triggerCube = bagProperties.contentsTriggerCube;
float centerOfTriggerCube = bag.transform.position.x + triggerCube.transform.localPosition.x;
float bagRightmostPos = centerOfTriggerCube + triggerCube.transform.localScale.x / 2f;
float bagLeftmostPos = centerOfTriggerCube - triggerCube.transform.localScale.x / 2f;
if (movement > 0 && bagRightmostPos < xrayScanLeft && bagRightmostPos + movement >= xrayScanLeft)
{
bagProperties.showItems(true);
}
else if (movement > 0 && bagLeftmostPos < xrayScanRight && bagLeftmostPos + movement >= xrayScanRight)
{
bagProperties.showItems(false);
}
else if (movement < 0 && bagLeftmostPos >= xrayScanRight && bagLeftmostPos + movement < xrayScanRight)
{
bagProperties.showItems(true);
}
else if (movement < 0 && bagRightmostPos >= xrayScanLeft && bagRightmostPos + movement < xrayScanLeft)
{
bagProperties.showItems(false);
}
if (movement > 0 && bagNewXPos > xRayMachine.xPointOfNoReturn)
{
bagProperties.bagFinished();
}
else
{
if (bagProperties.bagDefinition.person.showingPassport && bagProperties.bagDefinition.person.currentX >= xRayMachine.xPointOfNoBackingBags)
{
bagProperties.bagDefinition.person.showPassport(false);
}
if (movement > 0 || (movement < 0 && bag.transform.position.x < xRayMachine.xPointOfNoBackingBags))
{
bag.transform.position = new Vector3(bag.transform.position.x + movement, bag.transform.position.y, bag.transform.position.z);
}
}
}
}
PubSub.publish("belt_movement", movement);
}
}
internal BagProperties ToBag(DataBag dtBag)
{
var bagProperties = new BagProperties(null
, dtBag.Name, dtBag.Description
, new Vector3D(dtBag.Dimensions[0], dtBag.Dimensions[1], dtBag.Dimensions[2])
, dtBag.RoundingRadius);
bagProperties.SetWeight(dtBag.Weight);
bagProperties.SetNetWeight(new OptDouble(dtBag.NetWeight > 0, dtBag.NetWeight));
return(bagProperties);
}
public IEnumerator reportPersonAfterDelay(Person reportPerson, BagProperties inspectedBag, float delay = 0.3f)
{
yield return(new WaitForSeconds(delay));
BagHandler.instance.inspectBagDone(true);
int numberOfOkItems = inspectedBag.bagContents
.FindAll(item => item.actionTaken == InspectUIButton.INSPECT_TYPE.OK).Count;
yield return(new WaitForSeconds(delay * 2 + BagContentProperties.TIME_ANIMATE_TO_DROP_POINT + BagContentProperties.TIME_TO_TARGET_POS + numberOfOkItems * 0.05f));
reportPerson.reportToAuthorities();
}
public void callPolice()
{
Person reportPerson = currentInspectedItem.person;
BagProperties inspectedBag = currentInspectedItem.parentBag.GetComponentInParent <BagProperties>();
inspectDone();
Misc.AnimateMovementTo("call_police_move_" + id, this.gameObject, InspectUI.instance.callPolice.transform.localPosition);
Misc.AnimateScaleTo("call_police_scale_" + id, this.gameObject, Vector3.zero);
BagHandler.instance.bagInspectItemEnded();
StartCoroutine(reportPersonAfterDelay(reportPerson, inspectedBag));
}
public BagProperties getLeftmostBag()
{
BagProperties leftmostBag = null;
foreach (BagProperties bag in bags)
{
if (leftmostBag == null || leftmostBag.gameObject.transform.position.x > bag.gameObject.transform.position.x)
{
leftmostBag = bag;
}
}
return(leftmostBag);
}
public void setTeddyBearColor(BagProperties bag)
{
List <Color> teddyColors = getTeddyColors(chosenFavoriteColor);
GameObject teddybear = bag.teddybearWithMaterials;
// Add PerRendererShaders on teddybear and assign favorite colors on it
PerRendererShader teddyMain = teddybear.AddComponent <PerRendererShader>();
teddyMain.materialIndex = 0;
teddyMain.color = teddyColors[0];
PerRendererShader teddyTass = teddybear.AddComponent <PerRendererShader>();
teddyTass.materialIndex = 1;
teddyTass.color = teddyColors[1];
}
public void createBag(Vector3 bagDropPosition, String randomSeed)
{
// TODO - Random bag - Some distribution factor? Maybe not plastic tray except for certain content?
int randomBagIndex = ItsRandom.randomRange(0, bags.Length, randomSeed);
GameObject bagGameObject = Instantiate(bags [randomBagIndex], bagDropPosition, Quaternion.identity);
BagProperties bagProperties = bagGameObject.GetComponent <BagProperties> ();
bagGameObject.transform.position = new Vector3(bagDropPosition.x, bagDropPosition.y + bagProperties.halfBagHeight, bagDropPosition.z);
currentBagPlacing = bagProperties;
activeBags.Add(bagProperties);
if (bagProperties.lid != null)
{
bagProperties.lid.SetActive(false);
}
}
IEnumerator placeItemsInBagAndDrop(BagProperties bagProperties, List <BagContentProperties> items, String randomSeed)
{
Vector3 bagSize = bagProperties.placingCube.transform.localScale;
foreach (BagContentProperties item in items)
{
item.transform.parent = bagProperties.contents.transform;
Vector3 objectSize = item.objectSize;
item.transform.localPosition = new Vector3(ItsRandom.randomPlusMinus(0f, (bagSize.x - objectSize.x) / 2f, randomSeed), bagProperties.halfBagHeight, ItsRandom.randomPlusMinus(0f, (bagSize.z - objectSize.z) / 2f, randomSeed));
item.transform.localScale = Vector3.one;
bagProperties.bagContents.Add(item);
bagProperties.freezeContents(true);
yield return(new WaitForSeconds(0.1f));
}
yield return(new WaitForSeconds(0.6f));
dropBag(Vector3.zero);
}
public void createTrayWithContents(Vector3 dropPosition, List <BagContentProperties> items, PersonBagDefinition bagDefinition)
{
if (items != null && items.Count > 0)
{
GameObject bagGameObject = Instantiate(tray, dropPosition, Quaternion.identity);
BagProperties bagProperties = bagGameObject.GetComponent <BagProperties> ();
bagGameObject.transform.position = new Vector3(dropPosition.x, dropPosition.y + bagProperties.halfBagHeight, dropPosition.z);
currentBagPlacing = bagProperties;
bagProperties.bagDefinition = bagDefinition;
bagProperties.bagType = BagProperties.TYPE.TRAY_AFTER_INSPECT;
bagDefinition.addBag(bagProperties);
moveBagsAsideForTray(bagGameObject.GetComponent <BagProperties>());
StartCoroutine(placeItemsInBagAndDrop(currentBagPlacing, items, bagDefinition.bagRandomSeed));
// TODO - Need shuffle
activeBags.Add(bagProperties);
}
}
public IEnumerator fillLiquidBottles(BagProperties bag)
{
bool hadAnyLiquidBottles = false;
foreach (BagContentProperties bagContentPropertiese in bag.bagContents)
{
// TODO - More types to fill?
PillBottle pillBottle = bagContentPropertiese.GetComponent <PillBottle>();
if (!System.Object.ReferenceEquals(pillBottle, null))
{
bool willFillLiquid = pillBottle.fillLiquid();
if (willFillLiquid)
{
hadAnyLiquidBottles = true;
}
}
}
if (hadAnyLiquidBottles)
{
yield return(new WaitForSeconds(1.2f));
}
}
private void moveBagsAsideForTray(BagProperties bagProperties)
{
float trayDropPointX = Game.instance.getTrayDropPosition().x;
float trayPlacingWidth = bagProperties.placingCube.transform.localScale.x;
float trayRight = trayDropPointX + (trayPlacingWidth / 2f) * 1.5f;
List <BagProperties> bagsToMove = activeBags.FindAll(bag => {
float bagLeft = bag.transform.position.x - bag.placingCube.transform.localScale.x / 2f;
return(bagLeft <= trayRight);
});
List <GameObject> bagsToMoveObjects = new List <GameObject>();
BagProperties frontmostBag = null;
foreach (BagProperties bagToMove in bagsToMove)
{
if (frontmostBag == null || frontmostBag.transform.position.x < bagToMove.transform.position.x)
{
frontmostBag = bagToMove;
}
bagsToMoveObjects.Add(bagToMove.gameObject);
}
if (frontmostBag != null)
{
float frontMostBagLeft = frontmostBag.transform.position.x - frontmostBag.placingCube.transform.localScale.x / 2f;
float movementNeeded = (frontMostBagLeft - (trayDropPointX - trayPlacingWidth / 2f)) + frontmostBag.placingCube.transform.localScale.x * 1.35f;
string groupMovementId = "move_aside_for_tray_" + BagContentProperties.manualInspectTrayCounter;
Vector3 moveVector = new Vector3(-movementNeeded, 0, 0);
Misc.AnimateRelativeMovement(groupMovementId, bagsToMoveObjects, moveVector, 0.7f, true);
StartCoroutine(showItemsAfterDelay(bagsToMoveObjects, false, 0.7f));
}
}
IEnumerator shakeAndRotateBag(BagProperties bagProperties, float time = 1f)
{
GameObject bag = bagProperties.gameObject;
Quaternion startRotation = bag.transform.rotation;
Quaternion endRotation1 = Quaternion.Euler(0f, 0f, 20f) * startRotation;
Quaternion endRotation2 = Quaternion.Euler(0f, 0f, -20f) * startRotation;
float startTime = Time.time;
float endTime1 = (time / 4f) * 1f;
float endTime2 = (time / 4f) * 3f;
float endTime3 = (time / 4f) * 4f;
while (true)
{
float currentTime = Time.time - startTime;
if (currentTime <= endTime1)
{
bag.transform.rotation = Quaternion.Slerp(startRotation, endRotation1, currentTime / endTime1);
}
else if (currentTime <= endTime2)
{
bag.transform.rotation = Quaternion.Slerp(endRotation1, endRotation2, (currentTime - endTime1) / (endTime2 - endTime1));
}
else
{
bag.transform.rotation = Quaternion.Slerp(endRotation2, startRotation, (currentTime - endTime2) / (endTime3 - endTime2));
}
if (currentTime >= endTime3)
{
break;
}
yield return(null);
}
}
public PROPAGATION onMessage(string message, object data)
{
if (message == "Click")
{
if (Game.instance.cameraXPos == 2 && !Game.instance.zoomedOutState)
{
Vector3 position = Vector3.zero;
if (data.GetType() == typeof(Vector2))
{
Vector2 posV2 = (Vector2)data;
position = new Vector3(posV2.x, posV2.y);
}
else
{
position = (Vector3)data;
}
// Get camera
Camera camera = GetComponent <Game>().gameCamera;
RaycastHit hit;
Ray ray = camera.ScreenPointToRay(position);
if (bagInspectState == BagInspectState.NOTHING)
{
if (Physics.Raycast(ray, out hit))
{
Debug.Log(hit.transform.gameObject.name);
BagProperties clickedBagProperties = hit.transform.GetComponent <BagProperties>();
// // TODO - Can't contents be clicked directly when in a bag without lid?
// if (clickedBagProperties == null) {}
if (clickedBagProperties != null && !clickedBagProperties.isOpen)
{
clickedBagProperties.showItems(true);
clickedBagProperties.animateLidState(true);
clickedBagProperties.enableContentColliders(true);
currentBagInspect = clickedBagProperties;
bagInspectState = BagInspectState.BAG_OPEN;
clickedBagProperties.resetActionOnItems();
}
}
}
else if (bagInspectState == BagInspectState.BAG_OPEN)
{
// Debug.Log("Bag is open; " + BAG_CONTENTS_LAYER_MASK);
bool isBagEmpty = currentBagInspect.contents.transform.childCount == 0;
if (!isBagEmpty)
{
if (Physics.Raycast(ray, out hit, Mathf.Infinity, BAG_CONTENTS_LAYER_MASK))
{
Debug.Log(hit.transform.gameObject.name);
BagContentProperties clickedBagContentProperties = hit.transform.GetComponent <BagContentProperties>();
if (clickedBagContentProperties != null)
{
switchToGameCamera(true);
clickedBagContentProperties.inspect();
Misc.AnimateBlurTo("blurCamera", Game.instance.blurCamera.GetComponent <BlurOptimized>(), 1, 3f, 2);
bagInspectState = BagInspectState.ITEM_INSPECT;
PubSub.publish("inspect_active");
PubSub.publish("bag_inspect_item", new InspectActionBag(currentBagInspect.id, clickedBagContentProperties, InspectUIButton.INSPECT_TYPE.UNDEFINED));
}
}
}
else
{
// Bag is empty, if clicked - close it and end inspect state
if (Physics.Raycast(ray, out hit))
{
// Debug.Log(hit.transform.gameObject.name);
BagProperties clickedBagProperties = hit.transform.GetComponent <BagProperties>();
if (clickedBagProperties == currentBagInspect)
{
inspectBagDone();
}
}
}
}
}
}
return(PROPAGATION.DEFAULT);
}
IEnumerator placeItemsInBag(BagProperties bagProperties, int amount, List <BagContentProperties> toBePlacedInTrays, Person person, String randomSeed)
{
int yieldEveryXthItem = 5;
int yieldCounter = yieldEveryXthItem;
// float lastCycleStart = Time.realtimeSinceStartup;
Vector3 bagSize = bagProperties.placingCube.transform.localScale;
bagProperties.placingCube.SetActive(true);
Bounds bagBounds = bagProperties.placingCube.GetComponent <Collider>().bounds;
bagProperties.placingCube.SetActive(false);
// Debug.Log(bagBounds);
// TODO - Hidden items, make sure to check person config on frequency of putting these items in
// TODO - For now, always put one item
GameObject hiddenObj = ItsRandom.pickRandom <BagContentType>(bagContentTypesHidden.ToList(), randomSeed).contentObj;
GameObject hiddenItem = Instantiate(hiddenObj);
hiddenItem.transform.parent = bagProperties.transform;
BagContentProperties hiddenItemProperties = hiddenItem.GetComponent <BagContentProperties> ();
// Randomize place in bottom of bag
findPlaceForItemInBag(hiddenItemProperties, bagProperties, randomSeed, int.MaxValue, true);
bagProperties.bagContents.Add(hiddenItemProperties);
// TODO - This code block is only made for forcing an illegal item
GameObject gunObj = ItsRandom.pickRandom <BagContentType>(bagContentTypesIllegal.ToList(), randomSeed).contentObj;
GameObject gun = Instantiate(gunObj);
gun.transform.parent = bagProperties.contents.transform;
BagContentProperties gunProperties = gun.GetComponent <BagContentProperties> ();
// Randomize place in bag
findPlaceForItemInBag(gunProperties, bagProperties, randomSeed, int.MaxValue, false);
bagProperties.bagContents.Add(gunProperties);
// TODO - END
for (int i = 0; i < amount; i++)
{
List <int> weights = bagContentTypesLegal.Select(obj => obj.frequency).ToList();
List <GameObject> gameObjects = bagContentTypesLegal.Select(obj => obj.contentObj).ToList();
// TODO - below are the REAL CODE - NOT ABOVE
// List<int> weights = bagContentTypes.Select(obj => obj.frequency).ToList();
// List<GameObject> gameObjects = bagContentTypes.Select(obj => obj.contentObj).ToList();
GameObject randomGameObject = ItsRandom.pickRandomWithWeights(weights, gameObjects, randomSeed);
// Check if item should be in tray, or not instantiated by any other reason (eg. not place 3 guns in bag...)
bool acceptItem = true;
// TODO - Do this!
// bool acceptItem = randomGameObject.GetComponent<BagContentInstantiationRules>()(toBePlacedInTrays, person);
if (!acceptItem)
{
i--;
continue;
}
GameObject contentPiece = Instantiate(randomGameObject);
contentPiece.transform.parent = bagProperties.contents.transform;
// Randomly rotate 90°-angle
// TODO - When rotation turned on, objects seem to fall outside bag
// contentPiece.transform.localRotation = Quaternion.Euler(0f, 90f * Misc.random.Next(), 0f);
BagContentProperties bagContentProperties = contentPiece.GetComponent <BagContentProperties> ();
// Randomize place in bag
bool itemFitsInBag = findPlaceForItemInBag(bagContentProperties, bagProperties, randomSeed, 10, false);
if (itemFitsInBag)
{
bagContentProperties.person = person;
bagProperties.bagContents.Add(bagContentProperties);
// Trigger "random"-functions on it
RandomInterface[] randomInterfaces = contentPiece.GetComponents <RandomInterface>();
foreach (RandomInterface randomInterface in randomInterfaces)
{
randomInterface.run();
}
}
else
{
Debug.Log("Item removed: " + contentPiece);
contentPiece.transform.parent = null;
Destroy(contentPiece);
}
/*
* yieldCounter--;
* if (yieldCounter == 0) {
* yieldCounter = yieldEveryXthItem;
* // if (lastCycleStart + MAX_ITEM_PLACE_CYCLE_SECONDS < Time.realtimeSinceStartup) {
* Debug.Log("YIELD");
* yield return null;
* // // TODO - Compact items by code (move downwards)
* // yield return null;
* // lastCycleStart = Time.realtimeSinceStartup;
* }
*/
}
Debug.Log("Items in bag: " + bagProperties.bagContents.Count());
// Debug.Break();
yield return(null);
}
public BoxRounded(uint pickId, BagProperties bagProperties, BoxPosition position)
: base(pickId, bagProperties.Length, bagProperties.Width, bagProperties.Height, position)
{
Create(5, 0.5 * bagProperties.OuterDimensions - new Vector3D(bagProperties.Radius, bagProperties.Radius, bagProperties.Radius), bagProperties.Radius);
ColorFill = bagProperties.ColorFill;
}
public PROPAGATION onMessage(string message, object data)
{
if (message == "belt_movement")
{
if (bagDefinition.hasInitiated())
{
BagProperties leftmostBag = bagDefinition.getLeftmostBag();
Debug.Log("Leftmostbag " + leftmostBag);
if (leftmostBag != null && !leftmostBag.isDestroyed)
{
float leftMostBagPositionX = leftmostBag.gameObject.transform.position.x;
if (currentX < leftMostBagPositionX)
{
currentX = leftMostBagPositionX;
walkingMan.reportPositionX(currentX);
transform.position = new Vector3(leftMostBagPositionX, transform.position.y, transform.position.z);
// Check if person should show passport
BagProperties rightmostBag = bagDefinition.getRightmostBag();
GameObject triggerCube = rightmostBag.contentsTriggerCube;
float centerOfTriggerCube = rightmostBag.transform.position.x + triggerCube.transform.localPosition.x;
float bagRightmostPos = centerOfTriggerCube + triggerCube.transform.localScale.x / 2f;
float bagLeftmostPos = centerOfTriggerCube - triggerCube.transform.localScale.x / 2f;
if (bagRightmostPos >= Game.instance.currentXrayMachine.scanLeft && bagLeftmostPos <= Game.instance.currentXrayMachine.scanRight)
{
if (!showingPassport)
{
showPassport();
}
}
else if (showingPassport)
{
// showPassport(false);
}
// Check if we move past a certain point, to say our greeting
if (currentX > greetingPositionX && !haveSaidGreeting)
{
haveSaidGreeting = true;
playVoice(greeting);
}
}
}
else
{
walkingMan.finishWalkingMan();
finishPerson();
}
}
}
else if (message == "bag_inspect_item")
{
InspectActionBag bagInfo = (InspectActionBag)data;
bool isOurBag = bagDefinition.bags.Find(i => i.id == bagInfo.bagId) != null;
if (isOurBag)
{
if (bagInfo.action == InspectUIButton.INSPECT_TYPE.UNDEFINED)
{
setTimerAndReact(bagInfo.item);
}
else
{
stopTimerAndPossiblyReact(bagInfo.action, bagInfo.item);
}
}
// bagID
// start/stop
// throw away/ok/manual_inspect/police
}
return(default(PROPAGATION));
}
public void bagFinished(BagProperties bagProperties)
{
activeBags.Remove(bagProperties);
}
public SubContent(BagProperties bag)
{
BagProperties = bag;
}
private bool findPlaceForItemInBag(BagContentPropertiesBase item, BagProperties bagProperties, String randomSeed, int tries = 10, bool inBottom = false)
{
Vector3 bagSize = (
inBottom
? bagProperties.hiddenObjectsPlacingCube.transform.localScale
: bagProperties.placingCube.transform.localScale
);
Vector3 objectSize = item.transform.localRotation * item.objectSize;
bool objectsCollide = true;
List <Collider> allOtherColliders = bagProperties.bagContents.Aggregate(new List <Collider>(), (accumulator, otherItem) => {
accumulator.AddRange(otherItem.GetComponents <Collider>().ToList());
return(accumulator);
});
// Try to position object in bag for a number of times
while (objectsCollide && tries-- > 0)
{
bool haveAdjustedPos = false;
// Randomize position for object
item.transform.localPosition = new Vector3(ItsRandom.randomPlusMinus(0f, (bagSize.x - objectSize.x) / 2f, randomSeed), ItsRandom.randomPlusMinus(0f, (bagSize.y - objectSize.y) / 2f, randomSeed), ItsRandom.randomPlusMinus(0f, (bagSize.z - objectSize.z) / 2f, randomSeed))
+ (
inBottom
? bagProperties.hiddenObjectsPlacingCube.transform.localPosition
: bagProperties.placingCube.transform.localPosition
);
if (inBottom)
{
objectsCollide = false;
break;
}
while (true)
{
List <Collider> bagContentColliders = item.GetComponents <Collider>().ToList();
Vector3 direction = Vector3.zero;
float distance = 0f;
objectsCollide = bagContentColliders.Find(ownCollider => {
return(allOtherColliders.Find(otherCollider => {
return Physics.ComputePenetration(ownCollider, item.transform.localPosition, item.transform.localRotation, otherCollider, otherCollider.gameObject.transform.localPosition, otherCollider.gameObject.transform.localRotation, out direction, out distance);
}) != null);
}) != null;
if (objectsCollide)
{
if (haveAdjustedPos)
{
break;
}
// Move this object a bit and try again
item.transform.localPosition += direction * distance;
// Make sure we are still in the bag
if (Misc.isInside(item.transform.localPosition, objectSize, bagSize))
{
haveAdjustedPos = true;
}
else
{
break;
}
}
else
{
goto afterCollideDetection;
}
}
}
afterCollideDetection:
if (objectsCollide)
{
Debug.Log(item + ", NOK");
}
return(!objectsCollide);
}
