protected bool CheckEdge(CharacterControl charControl, List <GameObject> sphereList, Vector3 dir)
{
foreach (GameObject o in sphereList)
{
self = false;
Debug.DrawRay(o.transform.position, dir * blockDistance, Color.yellow);
RaycastHit hit;
if (Physics.Raycast(o.transform.position, dir, out hit, blockDistance))
{
foreach (Collider c in charControl.ragdollParts)
{
if (c.gameObject == hit.collider.gameObject && !Ledge.IsLedge(hit.collider.gameObject))
{
self = true;
break;
}
}
if (!self)
{
return(true);
}
}
}
return(false);
}
public override void OnInspectorGUI()
{
if (m_ledgeSettings == null)
{
m_ledgeSettings = (GlobalLedgeSettings)AssetDatabase.LoadAssetAtPath(m_ledgeSettingsPath, typeof(GlobalLedgeSettings));
}
// Assign selection
m_target = (Ledge)target;
// Apply updates from editor
TrimEmptyListEntries();
UpdateEdges();
// All that is seen in the inspector
GUILayout.Label("Ledge options", EditorStyles.boldLabel, GUILayout.Width(EditorGUIUtility.currentViewWidth - 19));
DrawGlobalVariableFields();
DrawSettingButtons();
GUILayout.Space(10);
GUILayout.Label("Add buttons", EditorStyles.boldLabel, GUILayout.Width(EditorGUIUtility.currentViewWidth - 19));
DrawVertexButtons();
GUILayout.Space(10);
GUILayout.Label("View of components in ledge", EditorStyles.boldLabel, GUILayout.Width(EditorGUIUtility.currentViewWidth - 19));
DrawDefaultInspector();
EditorUtility.SetDirty(m_target);
}
private bool IsGrounded(CharacterControl charControl)
{
if (charControl.RIGIDBODY.velocity.y <= 0.0f && charControl.RIGIDBODY.velocity.y > -0.01f)
{
groundTimer += Time.deltaTime;
if (groundTimer > 0.15f)
{
return(true);
}
}
if (charControl.RIGIDBODY.velocity.y < 0.0f)
{
foreach (GameObject o in charControl.bottomSpheres)
{
Debug.DrawRay(o.transform.position, Vector3.down * distance, Color.yellow);
RaycastHit hit;
if (Physics.Raycast(o.transform.position, Vector3.down, out hit, distance))
{
if (charControl.ragdollParts.Contains(hit.collider) && !Ledge.IsLedge(hit.collider.gameObject))
{
return(true);
}
}
}
}
return(false);
}
public override void Update(GameTime gameTime)
{
newLedgeTimer += gameTime.ElapsedGameTime;
if (newLedgeTimer.TotalMilliseconds > ledgeGenSpeed)
{
generateLedge();
newLedgeTimer = TimeSpan.Zero;
}
if (ledges.Count != 0 && ledges[0].offScreen())
{
Ledge oldLedge = ledges[0];
ledges.RemoveAt(0);
oldLedge = null; // Dispose
}
foreach (var ledge in ledges)
{
if (!ledge.passed())
{
// Logic with guardian needed here
}
}
}
// TODO MIXAMO.COM
// Bessere Jumpanimation
// Animation beim Aufkommen mit hoher Geschwindigkeit
// Step up animation
// Silly dancing animation
void Start()
{
if (!input)
{
input = GetComponent <GameInput>();
}
if (!ledge)
{
ledge = GetComponent <Ledge>();
}
if (!ledgeCol)
{
ledgeCol = GetComponent <LedgeColliding>();
}
if (!rig)
{
rig = GetComponent <Rigidbody>();
}
if (!jump)
{
jump = GetComponent <Jump>();
}
if (!movement)
{
movement = GetComponent <Movement>();
}
if (!animController)
{
animController = GetComponent <Animator>();
}
}
protected void Hanging(float elapsedTime)
{
VerticalSpeed = 0;
if (MecanimAnimator.GetBool(MecanimHashes.Hang))
{
if (ActiveHangTarget == null)
{
MecanimAnimator.SetBool(MecanimHashes.Fall, true);
return;
}
if (ActiveHangTarget.DoesFaceZAxis())
{
HorizontalSpeed = 0.0f;
Direction = Vector3.zero;
}
else
{
HorizontalSpeed = Direction.x * Settings.LedgeClimbingSpeed;
if (IsHangTargetToRight)
{
Direction = Vector3.right;
}
else
{
Direction = Vector3.left;
}
}
MecanimAnimator.SetBool(MecanimHashes.Hang, false);
}
if (ActiveHangTarget != null)
{
ActivePlatform = ActiveHangTarget.transform;
}
MecanimAnimator.SetBool(MecanimHashes.Fall, false);
if (ActiveHangTarget == null)
{
DropHangTarget();
MecanimAnimator.SetBool(MecanimHashes.Fall, true);
}
else if (ActiveHangTarget is Ledge && (CharInput.Up || InputMoveForward))
{
_ledge = ActiveHangTarget as Ledge;
MecanimAnimator.SetBool(MecanimHashes.ClimbLedge, true);
}
else if (CharInput.JumpPressed)
{
DropHangTarget();
MecanimAnimator.SetBool(MecanimHashes.Jump, true);
}
else if (CharInput.Down)
{
DropHangTarget();
MecanimAnimator.SetBool(MecanimHashes.Fall, true);
}
}
Ledge CheckForLedges(PlayerState state)
{
dir = state.Direction;
Ledge ledge = null;
var layerMask = Config.Get <PhysicsConfig>().StageLayers;
var colliders = ArrayPool <Collider> .Shared.Rent(256);
foreach (var region in CheckRegions)
{
var worldRegion = GetWorldRegion(region, state.Direction);
var colliderCount = Physics.OverlapBoxNonAlloc(worldRegion.center, worldRegion.extents, colliders, Quaternion.identity, layerMask, QueryTriggerInteraction.Collide);
for (var i = 0; i < colliderCount; i++)
{
ledge = colliders[i].GetComponent <Ledge>();
if (ledge != null)
{
break;
}
}
if (ledge != null)
{
break;
}
}
ArrayPool <Collider> .Shared.Return(colliders);
if (ledge)
{
Debug.LogWarning(ledge);
}
return(ledge);
}
private void OnTriggerEnter(Collider other)
{
if (other.tag == "Ledge")
{
ledge = other.transform.GetComponent <Ledge>();
CheckForClimb();
}
}
private void OnTriggerEnter(Collider other)
{
ledge = other.GetComponent <Ledge>();
if (ledge != null)
{
grabbedLedge = ledge;
isGrabbingLedge = true;
}
}
private void OnTriggerExit(Collider other)
{
ledge = other.GetComponent <Ledge>();
if (ledge != null)
{
grabbedLedge = null;
isGrabbingLedge = false;
}
}
static void CreateLadder(Transform ladder)
{
// Create the ladder at the correct position
GameObject createdLadder = GameObject.Instantiate(ladderPrefab, ladder.position, ladderPrefab.transform.rotation) as GameObject;
BoxCollider createdLadderCollider = createdLadder.GetComponent <BoxCollider> ();
bool facesZAxis = !ladder.name.Contains("X");
createdLadder.isStatic = true;
createdLadder.transform.parent = wallContainer.transform;
createdLadderCollider.center = ladder.GetComponent <Collider>().bounds.center - ladder.transform.position;
// Scale the ladder so that it encompasses the physical ladder and the player
createdLadderCollider.size = ladder.GetComponent <Collider>().bounds.size;
Vector3 size = createdLadderCollider.size;
CharacterController charController = playerPrefab.GetComponent <CharacterController> ();
if (facesZAxis)
{
size.z *= 100; // NOTE: 100 is an arbitrary number that should be large enough
}
else
{
size.x += charController.radius * playerPrefab.transform.localScale.z;
}
createdLadderCollider.size = size;
createdLadder.GetComponent <Ladder>().FacesZAxis = facesZAxis;
// Make sure any overlapping ledges can be accessed from the ladder
Collider[] nearbyColliders = Physics.OverlapSphere(createdLadder.transform.position, Mathf.Max(size.x, size.y));
foreach (Collider nearbyCol in nearbyColliders)
{
Ledge ledge = nearbyCol.GetComponent <Ledge>();
if (ledge != null)
{
Bounds ledgeColBounds = nearbyCol.bounds;
if (ledgeColBounds.Intersects(createdLadderCollider.bounds))
{
if (ledge.Left)
{
Vector3 min = ledgeColBounds.min;
min.x = Mathf.Min(ledgeColBounds.min.x, createdLadderCollider.bounds.min.x);
ledgeColBounds.min = min;
}
else
{
Vector3 max = ledgeColBounds.max;
max.x = Mathf.Max(ledgeColBounds.max.x, createdLadderCollider.bounds.max.x);
ledgeColBounds.max = max;
}
BoxCollider boxCol = nearbyCol as BoxCollider;
boxCol.center = ledgeColBounds.center - ledge.transform.position;
boxCol.size = ledgeColBounds.size;
}
}
}
createdLadderColliders.Add(createdLadderCollider);
}
public void Adding_a_new_ledge_will_return_ledge_with_Id()
{
var poco = new Ledge
{
ChapterId = 1,
Template = "bla" //TODO: Gültige Templates definieren
};
AddPoco(PostOrPutAction.Ledge, poco);
}
public void LedgeGrabbed(GameObject handPos, Ledge currentLedge)
{
_climbingUp = true;
_animator.SetBool("LedgeGrab", true);
_animator.SetFloat("Speed", 0);
_animator.SetBool("Jumping", false);
_controller.enabled = false;
transform.position = handPos.transform.position;
_currentLedge = currentLedge;
}
public override void SetUp(BattleObject obj)
{
base.SetUp(obj);
//These classes will be phased out as time goes on. Until then, we need to just exit early if we're in the builder since these don't actually use Subactions
if (isInBuilder)
{
return;
}
grabbed_ledge = actor.GetAbstractFighter().GrabbedLedge;
}
public void GrabLedge(Vector3 handPos, Ledge currentLedge)
{
_onLedge = true;
_controller.enabled = false;
_anim.SetBool("GrabLedge", true);
_anim.SetFloat("Speed", 0.0f);
_anim.SetBool("Jumping", false);
transform.position = handPos;
_activeLedge = currentLedge;
}
public void ExitLedge(Ledge ledge)
{
if (contacted_ledges.Contains(ledge))
{
contacted_ledges.Remove(ledge);
if (contacted_ledges.Count == 0)
{
LedgeLock = false;
}
}
}
public ActionResult GetLedgesPost(LedgesViewModel viewModel)
{
using (PriceDataModel2 db = new PriceDataModel2())
{
if (viewModel.coloredPriceFactor != 0 || viewModel.colorlessPriceFactor != 0)
{
Ledge ledge = db.Ledges.Where(p => p.Activity == true && p.PicValue == viewModel.system).FirstOrDefault();
Ledge newLedgePrice = new Ledge();
if (viewModel.colorlessPriceFactor != 0 && viewModel.coloredPriceFactor == 0)
{
newLedgePrice.Activity = ledge.Activity;
newLedgePrice.Colored = ledge.Colored;
newLedgePrice.ColoredPriceFactor = ledge.ColoredPriceFactor;
newLedgePrice.Colorless = ledge.Colorless;
newLedgePrice.ColorlessPriceFactor = viewModel.colorlessPriceFactor;
newLedgePrice.Model = ledge.Model;
newLedgePrice.PicValue = ledge.PicValue;
db.Ledges.Add(newLedgePrice);
db.SaveChanges();
}
if (viewModel.coloredPriceFactor != 0 && viewModel.colorlessPriceFactor == 0)
{
newLedgePrice.Activity = ledge.Activity;
newLedgePrice.Colored = ledge.Colored;
newLedgePrice.ColoredPriceFactor = viewModel.coloredPriceFactor;
newLedgePrice.Colorless = ledge.Colorless;
newLedgePrice.ColorlessPriceFactor = ledge.ColorlessPriceFactor;
newLedgePrice.Model = ledge.Model;
newLedgePrice.PicValue = ledge.PicValue;
db.Ledges.Add(newLedgePrice);
db.SaveChanges();
}
if (viewModel.coloredPriceFactor != 0 && viewModel.colorlessPriceFactor != 0)
{
newLedgePrice.Activity = ledge.Activity;
newLedgePrice.Colored = ledge.Colored;
newLedgePrice.ColoredPriceFactor = viewModel.coloredPriceFactor;
newLedgePrice.Colorless = ledge.Colorless;
newLedgePrice.ColorlessPriceFactor = viewModel.colorlessPriceFactor;
newLedgePrice.Model = ledge.Model;
newLedgePrice.PicValue = ledge.PicValue;
db.Ledges.Add(newLedgePrice);
db.SaveChanges();
}
ledge.Activity = false;
db.Entry(ledge).State = EntityState.Modified;
db.SaveChanges();
}
return(RedirectToAction("GetLedges", "Price"));
}
}
public void GrabLedge(Vector3 position, Ledge currentLedge)
{
transform.position = position;
_grabbingLedge = true;
_anim.SetBool("GrabLedge", true);
_anim.SetBool("Jump", false);
_anim.SetFloat("Speed", 0);
_controller.enabled = false;
if (currentLedge != null)
{
_activeLedge = currentLedge;
}
}
/// <summary>
/// Checks for collision with walls in front of player
/// if wall is detected, switch to climbing state
/// </summary>
public void FrontCollisionTest()
{
if (playerState == State.WALLRUN_LEFT || playerState == State.WALLRUN_RIGHT)
{
return;
}
if (virtualController.ClimbButtonPressed && playerState != State.CLIMB && canClimb)
{
ledge = ledgeDetector.GetLedgeV2();
if (!ledge.empty)
{
SwitchStates(State.CLIMB, ClimbMove);
}
}
}
void Start()
{
if (!anim)
{
anim = GetComponent <Animator>();
}
if (!ledge)
{
ledge = GetComponent <Ledge>();
}
if (!jump)
{
jump = GetComponent <Jump>();
}
}
/// <summary>
/// Creates a new calculator
/// </summary>
/// <param name="ledge">The ledge</param>
/// <param name="character">The character informations</param>
/// <param name="margin">The margin</param>
public LedgeGrabCalculator(Ledge ledge, CharacterInfo character, float margin = 0F)
{
Ledge = ledge;
Character = character;
Margin = margin;
_radius = Character.Radius + margin;
CalcRelativePosition();
CalcRawGrabPosition();
CalcGrabDirection();
ValidateRawGrabPosition();
CalcSafeGrabPosition();
CalcFinalGrabPosition();
CalcCrossing();
}
public bool CanPlayerJump(FacingDirection facingDirection)
{
RaycastHit2D[] hits = Physics2D.RaycastAll(this.m_collider.bounds.center, FacingDirectionToVector(facingDirection), m_distanceForEachStep * 1.2f);
foreach (var hit in hits)
{
Ledge ledgeComponent = hit.collider.GetComponent <Ledge>();
if (ledgeComponent == null)
{
continue;
}
if (ledgeComponent.GetJumpableDirection() == this.m_facingDirection)
{
return(true);
}
}
return(false);
}
protected void generateLedge()
{
int gap = (rand.Next(gameWidth - 96) / ledgeSprites[0].Width);
if (gap == 0)
{
gap = 1;
}
gap *= ledgeSprites[0].Width;
Ledge tmpLedge = new Ledge(game, gameWidth, gameHeight, gap, (ledgeSprites[0].Width * 2), ledgeSprites, rand);
int ghost = rand.Next(gameWidth);
// 10% chance of spawning a Ghost
if (ghost % 10 == 7)
{
tmpLedge.triggerGhost(game, ghost, ghostSprite);
}
ledges.Add(tmpLedge);
}
public byte PlayersHit; // 1 byte
public void GrabLedge(Ledge ledge)
{
GrabbedLedgeID = ledge.Id;
GrabbedLedgeTimer = Config.Get <GameplayConfig>().MaxLedgeHangTime;
}
// Start is called before the first frame update
void Start()
{
animator = GetComponent <Animator>();
ledgeScript = GetComponent <Ledge>();
grabbableLayer = ledgeScript.grabbableLayer;
}
public void GetTrumped(Ledge ledgeTrumpedFrom)
{
Debug.Log("CAN'T STUMP THE LEDGE TRUMP");
}
public void ReleaseLedge()
{
grabbed_ledge = null;
}
public void GrabLedge(Ledge ledgeToGrab)
{
grabbed_ledge = ledgeToGrab;
LedgeLock = true;
doAction("LedgeGrab");
}
public void EnterLedge(Ledge ledge)
{
contacted_ledges.Add(ledge);
}
public void Adding_a_story_will_succeed()
{
var story = new Story
{
Name = "Test",
HeaderPhotoId = 54,
Chapters = new List <Chapter>(),
MemberId = 3
};
var chapter = new Chapter
{
Name = "Neues Kapitel",
Order = 1,
Ledges = new List <Ledge>()
};
var ledge = new Ledge
{
Order = 1,
Template = "LL",
Bricks = new List <Brick>()
};
var brick1 = new TextBrick
{
Order = 1,
Type = "text",
Text = "Neuer Text"
};
var brick2 = new MapBrick
{
Order = 2,
Type = "map",
Longitude = 51.210581,
Latitude = 3.222145,
Zoom = 0
};
var brick3 = new PhotoBrick
{
Order = 3,
Type = "photo",
PhotoId = 54
};
ledge.Bricks = new List <Brick> {
brick1, brick2, brick3
};
chapter.Ledges = new List <Ledge> {
ledge
};
story.Chapters = new List <Chapter> {
chapter
};
_repository.Add(story);
Assert.IsTrue(story.Id != 0, "Story wurde nicht gespeichert");
_repository.Delete(story);
}
