/// <summary>
/// Define if the object needs to be freezed. Acts like a switch.
/// </summary>
protected void freezeObject()
{
if (m_currentObject.GetComponent <MovableObject>() != null)
{
m_currentObject.GetComponent <MovableObject>().isFreezed = !m_currentObject.GetComponent <MovableObject>().isFreezed;
}
}
void OnFruitNinjaClickedBubble(Fruit.types type)
{
switch (type)
{
case Fruit.types.GENERIC:
fruitsManager.audioSource.PlayOneShot(ninjaOK);
fruitsManager.audioSource.PlayOneShot(rompehielo);
points += 1;
break;
case Fruit.types.BAD:
fruitsManager.audioSource.PlayOneShot(ninjaWrong);
points -= 1;
break;
}
if (points < 0)
{
points = 0;
}
else if (points >= totalPoints)
{
points = totalPoints;
Done(true);
}
float v = 1 - (float)points / (float)totalPoints;
Data.Instance.ui.progressBar.SetValue(v);
interactiveObject.GetComponent <Door> ().SetProgress(v);
}
void OnCharacterHitInteractiveObject(InteractiveObject io)
{
if (state != states.PLAYING || state == states.CHANGING_LEVEL || state == states.UI_POPUP)
{
return;
}
PortalLevel portalLevel = io.GetComponent <PortalLevel> ();
if (portalLevel != null)
{
if (portalLevel.ChekToCross())
{
selectedInteractiveObject = io;
//anim.Idle ();
//state = states.CHANGING_LEVEL;
return;
}
}
Door door = io.GetComponent <Door> ();
if (door == null)
{
return;
}
if (door.state == Door.states.UNAVAILABLE)
{
Events.PortalUnavailable();
return;
}
if (door.state == Door.states.BLOCKED || door.state == Door.states.COMPLETED)
{
return;
}
if (door.state == Door.states.CLOSED)
{
selectedInteractiveObject = io;
Vector3 newPos = io.transform.localPosition;
newPos.z -= 1.5f;
OnFloorClicked(newPos);
state = states.OPENING_FRUIT_NINJA;
}
else
{
selectedInteractiveObject = io;
Door d = selectedInteractiveObject as Door;
nextScene = Data.Instance.GetNextMGame();
Vector3 newPos = io.transform.localPosition;
newPos.z -= 0.35f;
OnFloorClicked(newPos);
state = states.ENTERING_DOOR;
}
}
public void PlaceGameObjectFromStaticRef(InteractiveObject _go, int _x, int _y, int _rotation, float _hight = 0)
{
if (_go == null || _go.gameObject == null)
{
return;
}
if (_hight == 0)
{
_go.transform.position = ActorMoveFSM.LineCast(new Vector3(_x, 0, _y), true);
}
else
{
_go.transform.position = new Vector3(_x, _hight, _y);
}
Actor actor = _go.GetComponent <Actor>();
if (actor != null)
{
actor.FaceToNoLerp(_rotation);
}
else
{
_go.transform.localEulerAngles = new Vector3(0, _rotation, 0);
}
OnPositionChanged(_go);
}
public void PlaceGameObjectFromServer(InteractiveObject _go, float _x, float _y, int _rotation, float _hight = 0)
{
if (_go == null || _go.gameObject == null)
{
return;
}
if (_hight == 0)
{
_go.transform.position = ActorMoveFSM.LineCast(new Vector3(_x, 0, _y), true);
}
else
{
_go.transform.position = new Vector3(_x, _hight, _y);
}
Vector3 dir = Utils.Int2ToDir(_rotation);
Actor actor = _go.GetComponent <Actor>();
if (actor != null)
{
actor.FaceToNoLerp(_rotation);
actor.PositionChange();
}
else
{
_go.transform.forward = dir;
}
OnPositionChanged(_go);
}
/// <summary>
/// Überprüft das World Object auf Pushes und Kollsionen.
/// </summary>
/// <param name="worldObject"></param>
private void CheckWorldObjectCollision(WorldObject worldObject)
{
Collider2D collider = worldObject.GetComponent <Collider2D>();
RayCaster raycaster = worldObject.GetComponent <RayCaster>();
Collider2D[] detectedCollider = new Collider2D[1];
ContactFilter2D contactFilter = new ContactFilter2D();
contactFilter.layerMask = raycaster.collisionMask;
contactFilter.useLayerMask = true;
/*GameObject test = new GameObject();
* test.layer = LayerMask.NameToLayer("Goals");
* Debug.Log("!!!!!!!!!" + contactFilter.IsFilteringLayerMask(test));*/
collider.OverlapCollider(contactFilter, detectedCollider);
if (detectedCollider[0] != null && detectedCollider[0].GetComponent <InteractiveObject>())
{
Debug.Log("*" + worldObject.gameObject.name + " Overlap mit " + detectedCollider[0].name);
InteractiveObject interactiveObject = detectedCollider[0].GetComponent <InteractiveObject>();
Vector2 dir = detectedCollider[0].transform.position - worldObject.transform.position;
float angleBetweenObjects = Mathf.Atan2(dir.y, dir.x) * Mathf.Rad2Deg;
//Debug.Log("**Winkel dazwischen: " + angleBetweenObjects);
Debug.DrawLine(detectedCollider[0].transform.position, worldObject.transform.position, Color.green);
Vector2 pushDirection = GetDirectionVectorForRoundedAngle(angleBetweenObjects + 90); //Es werden 90° addiert, weil angleBetweenObjects einen anderen Standard-Winkel hat als der Rest des Spiels.
if (CanPushObject(worldObject.GetComponent <InteractiveObject>(), interactiveObject, pushDirection))
{
worldObject.GetComponent <InteractiveObject>().Push(interactiveObject, pushDirection);
}
else if (interactiveObject.GetComponent <RayCaster>().CheckForCollisionsInDirection(pushDirection))
{
Debug.LogError(gameObject.name + " kann sich nicht in die angegebene Richtung bewegen, weil es zur Kollision kommen würde.");
}
}
}
/// <summary>
/// Überprüf, ob das erste übergebene WorldObject das Zweite schieben darf.
/// </summary>
/// <param name="pusher"></param>
/// <param name="target"></param>
/// <param name="pushDirection"></param>
/// <returns></returns>
private bool CanPushObject(InteractiveObject pusher, InteractiveObject target, Vector2 pushDirection)
{
if (!target.Movable)
{
Debug.Log("***" + pusher.name + " kann " + target.name + " nicht schieben, weil " + target.name + " nicht bewegbar ist.");
return(false);
}
if (target.GetComponent <RayCaster>().CheckForCollisionsInDirection(pushDirection))
{
Debug.LogError("***" + target.name + " kann sich nicht in die angegebene Richtung bewegen, weil es zur Kollision kommen würde.");
return(false);
}
if (Vector2.Distance(pusher.transform.position, target.transform.position) >= 0.9f)
{
Debug.Log("***" + pusher.name + " kann " + target.name + " nicht schieben, weil die beiden zu weit voneinander entfernt sind.");
return(false);
}
if (Vector2.Distance(pusher.transform.position, new Vector2(target.posX + 0.5f, target.posY + 0.5f)) >= 1)
{
Debug.Log("***" + pusher.name + " kann " + target.name + " nicht schieben, weil " + pusher.name + " zu weit von " + target.name + "s Zielposition(" + target.posX + "/" + target.posY + ") entfernt ist(Distanz: " + Vector2.Distance(pusher.transform.position, new Vector2(target.posX, target.posY)) + ")");
return(false);
}
if (target.posX == pusher.oldX && target.posY == pusher.oldY)
{
Debug.Log("***" + pusher.name + " kann " + target.name + " nicht schieben, weil es von ihm geschoben wurde.");
return(false);
}
return(true);
}
void OpenFruitNinja(InteractiveObject _interactiveObject)
{
totalPoints = 3 + (Data.Instance.levelsData.actualDiamondLevel * 2);
timer = 0;
Data.Instance.ui.StartTimer();
playing = true;
Events.OnDragger(true);
this.interactiveObject = _interactiveObject;
points = 0;
Data.Instance.ui.progressBar.SetValue(1);
Game.Instance.ChangeMode(Game.modes.FRUIT_NINJA);
fruitsManager.gameObject.SetActive(true);
fruitsManager.Init();
interactiveObject.GetComponent <Door> ().Reset();
interactiveObject.GetComponent <Door> ().SetProgress(1);
}
private void HitResult(Collision2D collision)
{
HealthAbility health = hitObject.GetComponent <HealthAbility>();
health?.DoDamage(Damage);
ShowEffects(collision);
OnDamage();
}
private void Pickup(InteractiveObject pickUp)
{
if (!_pickedUpObject.Contains(pickUp))
{
_pickedUpObject.Add(pickUp);
DistanceJoint2D newJoint = _handTransform.gameObject.AddComponent <DistanceJoint2D>();
newJoint.connectedBody = pickUp.GetComponent <Rigidbody2D>();
newJoint.distance = 0.01f;
newJoint.maxDistanceOnly = true;
}
}
private void CheckHitObject(RaycastHit2D hit, ObjectType[] damagable)
{
InteractiveObject interactive = hit.collider.gameObject.GetComponent <InteractiveObject>();
if (!interactive)
{
return;
}
else if (!damagable.Contains(interactive.Type))
{
return;
}
interactive.GetComponent <HealthAbility>()?.DoDamage(Damage);
}
/// <summary>
/// Dreht das Objekt um 90° im Uhrzeigersinn.
/// </summary>
public void TurnRight()
{
Vector2 temp = oldDirection;
oldDirection = direction;
direction = new Vector2(oldDirection.y, -oldDirection.x);
if (GetComponent <Robot>() && GetComponent <Robot>().GrabbedObject != null)
{
List <InteractiveObject> grabbedObjects = new List <InteractiveObject>();
InteractiveObject grabbedObject = GetComponent <Robot>().GrabbedObject;
grabbedObjects.Add(grabbedObject);
if (grabbedObject.GetComponent <WorldObjectGroup>())
{
foreach (WorldObject obj in grabbedObject.GetComponent <WorldObjectGroup>().objects)
{
grabbedObjects.Add(obj.GetComponent <InteractiveObject>());
}
}
grabbedObject.AdjustRelativePosition("Right");
grabbedObject.MoveToRelativePosition();
}
gameObject.transform.rotation = Quaternion.AngleAxis(GetFacingAngle(direction), Vector3.forward);
}
private void OnTriggerEnter2D(Collider2D collision)
{
InteractiveObject interactive = collision.gameObject.GetComponent <InteractiveObject>();
if (!interactive)
{
return;
}
else if (!damageObjects.Contains(interactive.Type))
{
return;
}
interactive.GetComponent <HealthAbility>()?.DoDamage(Damage);
collider.enabled = false;
}
private void Update()
{
bool foundSomethingToInteractWith = false;
RaycastHit hitInfo;
foreach (Transform checkOrigin in _checkOrigins)
{
LayerMask layerMask = LayerMask.GetMask("Interactive");
// If we are holding an item, we are only going to interact with the objects that the item we are holding can interact with
if (_player.PlayerPickAnimator.HoldingItem)
{
layerMask = _player.PlayerPickAnimator.InteractivePickable.InteractLayerMask;
}
if (Physics.Raycast(checkOrigin.position, checkOrigin.transform.forward, out hitInfo, _checkDistance, layerMask) ||
_player.PlayerWallClimb.CanMount)
{
foundSomethingToInteractWith = true;
UIManager.Instance.SetInteractiveSignal(true);
if (_player.PlayerPickAnimator.HoldingItem && GameManager.Instance.InputManager.Interact)
{
// Here, we use the item we are holding
_player.PlayerPickAnimator.Use(hitInfo.transform);
_player.transform.forward = -hitInfo.normal;
}
else
{
// We don't need to interact with objects when we are in climb mode
if (_player.PlayerState.PlayerMoveState != PlayerMoveState.WallClimbing)
{
if (GameManager.Instance.InputManager.Interact && hitInfo.transform != null)
{
InteractiveObject interactiveObject = hitInfo.transform.GetComponentInChildren <InteractiveObject>();
if (interactiveObject != null)
{
// If it's a breakable door, then we play the kick animation first
InteractiveDoor interactiveDoor = interactiveObject.GetComponent <InteractiveDoor>();
if (interactiveDoor != null && interactiveDoor.Breakable && interactiveDoor.IsClosed)
{
_interactiveDoor = interactiveDoor;
Quaternion lookRotation = Quaternion.LookRotation((interactiveDoor.transform.position - _player.transform.position).normalized);
_player.transform.rotation = Quaternion.Euler(_player.transform.rotation.eulerAngles.x, lookRotation.eulerAngles.y, _player.transform.rotation.eulerAngles.z);
//_player.transform.forward = (interactiveDoor.transform.position - _player.transform.position).normalized;
_player.Animator.SetTrigger("Kick");
}
else
{
interactiveObject.Interact(transform);
}
break;
}
}
}
}
}
}
if (!foundSomethingToInteractWith)
{
UIManager.Instance.SetInteractiveSignal(false);
}
// if we are holding an item and we are in front of a target object of the item we are holding, then we should set the canuse variable of playerPickAnimator script
if (_player.PlayerPickAnimator.HoldingItem && foundSomethingToInteractWith)
{
_player.PlayerPickAnimator.CanUse = true;
}
else
{
_player.PlayerPickAnimator.CanUse = false;
}
}
public override void Execute()
{
Camera cam = InteractiveObject.GetComponent <Camera>();
CameraController.switchCamera(cam);
}
/// <summary>
/// Überprüft, ob auf dem Feld vor dem WorldObject ein interaktives Objekt liegt.
/// </summary>
public DynValue CheckForInteractiveObjectInFront()
{
//Debug.Log(gameObject.name + " looks for an Object in its front.");
Table sensedData = new Table(script);
InteractiveObject temp = GetComponent <RayCaster>().CheckForInteractiveObject(myInteractiveObject.direction);
if (temp != null)
{
//Wenn ein Interaktives Objekt vor dem Roboter steht wird es analysiert.
sensedData["x"] = temp.posX;
sensedData["y"] = temp.posY;
sensedData["direction"] = temp.GetFacingAngle(temp.direction);
sensedData["movable"] = temp.Movable;
sensedData["grabable"] = temp.Grabable;
sensedData["color"] = "none";
if (temp.grabbedBy != null)
{
sensedData["grabbedBy"] = temp.grabbedBy.name;
}
else
{
sensedData["grabbedBy"] = "none";
}
Robot tempBot = temp.GetComponent <Robot>();
if (tempBot != null)
{
sensedData["type"] = "Robot";
}
WorldObject tempObj = temp.GetComponent <WorldObject>();
if (tempObj != null)
{
sensedData["type"] = tempObj.objectType;
sensedData["color"] = tempObj.objectColor.ToString();
}
}
else if (GetComponent <RayCaster>().CheckForCollisionsInDirection(myInteractiveObject.direction))
{
//Wenn kein Interaktives Objekt vor dem Roboter steht, er aber trotzdem kollidieren würde, muss eine Wand vor ihm sein.
sensedData["type"] = "Wall";
sensedData["movable"] = false;
sensedData["grabable"] = false;
sensedData["grabbedBy"] = "none";
sensedData["direction"] = -1;
sensedData["color"] = "none";
sensedData["x"] = myInteractiveObject.posX + myInteractiveObject.direction.x;
sensedData["y"] = myInteractiveObject.posY + myInteractiveObject.direction.y;
}
else
{
//Wenn auch keine Kollision stattfinden würde, ist das Tile vor dem Roboter leer.
sensedData["type"] = "Nothing";
sensedData["movable"] = false;
sensedData["grabable"] = false;
sensedData["grabbedBy"] = "none";
sensedData["direction"] = -1;
sensedData["color"] = "none";
sensedData["x"] = myInteractiveObject.posX + myInteractiveObject.direction.x;
sensedData["y"] = myInteractiveObject.posY + myInteractiveObject.direction.y;
}
return(DynValue.NewTable(sensedData));
}
public void AddIngredient(InteractiveObject ingredient)
{
currentBrew.Add(ingredient.GetComponent <IngredientObject>().GetIngredient());
CheckBrew();
}
public void OnItemTakeByVisitor(ObtainableItem item)
{
barrel.GetComponent <PlaysAnimationOnSight>().isAbleToInteractAfterAnimation = false;
}
