public HammerEvent(HitInfo info, BasePlayer player) { _info = info; basePlayer = player; string bonename = StringPool.Get(info.HitBone); HitBone = bonename == "" ? "unknown" : bonename; }
private EventManager() { this.initializedFlag = false; this.initializedListener = null; this.hitInfoListener = null; this.lastHitInfo = null; }
public override RealHitInfo DelayedHitCalc(Line by, HitInfo hit) { RealHitInfo realHit = new RealHitInfo(); realHit.HitStuff = Surface; realHit.Pigment = Pigment; realHit.Normal = new Line(); realHit.Normal.Start = by.Project(hit.HitDist); realHit.Normal.Direct.Dx = 0; realHit.Normal.Direct.Dy = 0; realHit.Normal.Direct.Dz = 0; switch (hit.SurfaceIndex) { case 0: Point hitLoc2 = inv.Apply(realHit.Normal.Start); realHit.Normal.Direct.Dx = hitLoc2.X; realHit.Normal.Direct.Dy = hitLoc2.Y; realHit.Normal.Direct.Dz = hitLoc2.Z; break; default: throw new InvalidOperationException("Invalid surface index in hitdata"); } Vector before = realHit.Normal.Direct; realHit.Normal.Direct = trans.Apply(realHit.Normal.Direct); if (realHit.Normal.Direct.Dot(by.Direct) > 0) { realHit.Normal.Direct.ScaleSelf(-1.0); } return realHit; }
public void killedPlayer(HitInfo hit) { totalKills++; // increment total kills if (hit.player.nickname != null) playerKills [hit.player.nickname]++; // increment player kills - use nickname translateKillToScore (hit.pokemon.level); // transalte kill to score }
public override void Kill() { var info = new HitInfo(); info.damageTypes.Add(Rust.DamageType.Suicide, 100f); info.Initiator = baseNPC as BaseEntity; baseNPC.Die(info); }
public override void OnFire(HitInfo hit) { bool canFire = true; if(interval) { if(Time.time - lastGunshotTime < gunshotInterval) { canFire = false; } else { lastGunshotTime = Time.time; } } if(canFire) { AudioChannel audioChannel = audioManager.PlayAt(gunshot, ((Firearm)Weapon).Position); if(audioChannel != null) { audioChannel.Pitch = Random.Range(gunshotPitchRange.x, gunshotPitchRange.y); SetSpatialBlend(audioChannel); } } }
private void Kill() { HitInfo hitInfo = new HitInfo(Entity, Entity, Vector3.zero, Vector3.zero, "Untagged"); DamageInfo damageInfo = new DamageInfo(hitInfo, health.CurrentHealth); GlobalEvents.Invoke(new WeaponDamageEvent(null, damageInfo)); }
private void Damage(float damage) { HitInfo hitInfo = new HitInfo(Entity, Entity, Vector3.zero, Vector3.zero, "Untagged"); DamageInfo damageInfo = new DamageInfo(hitInfo, damage); GlobalEvents.Invoke(new WeaponDamageEvent(null, damageInfo)); }
public BuildingPartDestroyedEvent(BuildingBlock buildingBlock, HitInfo info) { BuildingPart = new BuildingPart(buildingBlock); Info = info; string bonename = StringPool.Get(info.HitBone); HitBone = bonename == "" ? "unknown" : bonename; }
/// <summary> /// Recieve an attackValue. /// </summary> /// <param name="sender">Who sent the attackValue.</param> /// <param name="hitInfo">Attack info associated with the attackValue.</param> public virtual void RecieveHit(List<object> senders, int hitID, HitInfo hitInfo) { if (hitID == lastHitID) return; if (invincible) return; lastHitID = hitID; int damage = hitInfo.damage; // status effect if (hitInfo.effect != HitInfo.Effects.None) { damage = Mathf.CeilToInt(damage * statusEffectivenesses[(int)hitInfo.effect]); if (damage > 0) { Log(hitInfo.effect + ":" + (int)hitInfo.effect, Debugger.LogTypes.Combat); StopAllCoroutines(); StartCoroutine(statusMethods[(int)hitInfo.effect], damage); } } ChangeHealth(-damage); CreateIndicator(damage); //if (HitEvent != null) //{ // HitEvent(senders, new HitEventArgs(hitInfo, currentHealth, damage)); //} if (HitEvent != null) { HitEvent(senders, new HitEventArgs(hitInfo, currentHealth, damage)); } }
protected override void PrimaryFire() { for (int i = 0; i < pelletCount; i++) //for each pellet, shoot one in a random direction based off the cone { RaycastHit hit; //Bullet recoil stuff and it's direction Quaternion fireRot = Quaternion.LookRotation(transform.forward); Quaternion randomRot = Random.rotation; float currentSpread = bulletSpreadCurve.Evaluate(fireTime / timeTillMaxSpreadAngle) * maxBulletSpreadAngle; //changes bulllet angle fireRot = Quaternion.RotateTowards(fireRot, randomRot, Random.Range(0.0f, currentSpread)); //randomises it within said cone if (Physics.Raycast(transform.position, fireRot * Vector3.forward, out hit, Mathf.Infinity)) { HitInfo hitInfo = new HitInfo(); //send hitInfo stuff hitInfo.damage = damage; hitInfo.raycastHit = hit; hit.collider.gameObject.SendMessage("GunHitInfo", hitInfo, SendMessageOptions.DontRequireReceiver); //send damage and position of hit } } }
public override void PlayHitAnimation(int totalHealth, HitInfo hitInfo) { if (_animator.GetCurrentAnimatorStateInfo(0).IsName(_animationClipName[EUnitAnimationState.Skill_ClipDischarge]) || _animator.GetCurrentAnimatorStateInfo(0).IsName(_animationClipName[EUnitAnimationState.Skill_StunGrenade])) { return; } base.PlayHitAnimation(totalHealth, hitInfo); }
public override void OnFire(HitInfo hit) { Remaining--; if(Remaining <= 0) { Weapon.Wielder.Events.Invoke(new MagazineEmptyEvent()); Weapon.StopFire(true); } }
public CombatEntityHurtEvent(BaseCombatEntity combatEnt, HitInfo info) : base(info) { var block = combatEnt.GetComponent<BuildingBlock>(); if (block != null) Victim = new BuildingPart(block); else Victim = new Entity(combatEnt); }
public bool Check() { var hit = LocalCache.TryGet<object>(this.CacheKey) as HitInfo; if (hit != null) { return hit.Counter++ < this.Limit; } hit = new HitInfo { Counter = 1 }; Dependency.Resolve<ILocalCache>().Add(this.CacheKey, hit, this.Duration); return true; }
protected override void OnCollisionEnter2D(Collision2D collision) { m_animator.SetBool(m_hitHash, true); GetComponent<Rigidbody2D>().isKinematic = true; HitInfo info = new HitInfo(); info.hitEnergy=Damage; foreach(GameObject x in m_targets) { if(x!= null) x.SendMessage("OnHit", info); } m_hit = true; }
public override void OnFire(HitInfo hit) { burstId++; switch(current) { case FireMode.SemiAutomatic: Weapon.StopFire(true); break; case FireMode.Burst3: UpdateBurst(); break; } }
public override float GetDamage(HitInfo hit, float damage) { switch(hit.tag) { case "Head": return damage * head; case "Body": return damage * body; case "Limbs": return damage * limbs; } return damage; }
/// <summary> /// Create a new hitbox with new data. /// </summary> /// <param name="sender">Character who sent the attackValue.</param> /// <param name="hitInfo">HitInfo to pass along to the reciever's Health.</param> /// <param name="time">How long the hitbox should last.</param> /// <param name="hitNumber">How many hits to perform. Usually 1.</param> /// <param name="oneShot">Does the hitbox get destroyed after landing one hit?</param> public void Initialize(List<object> senders, HitInfo hitInfo, float time, int hitNumber, bool oneShot = false) { this.senders = senders; this.hitInfo = hitInfo; this.oneShot = oneShot; tag = (senders[0] as MonoBehaviour).tag; SetHitID(); if (hitNumber > 1) { StartCoroutine(MultiHit(time, hitNumber)); } InvokeMethod("End", time); }
protected override void OnCollisionEnter2D(Collision2D collision) { float hitEnergy = Mathf.Abs(m_energy - Mass * rigidbody2D.velocity.SqrMagnitude() / 2); if (hitEnergy > 1) { Strength -= hitEnergy; HitInfo info = new HitInfo(); info.velocity = rigidbody2D.velocity; info.mass = Mass; info.hitEnergy = hitEnergy; collision.collider.SendMessage("OnHit", info); } if (Strength <= 0) Destroy(gameObject); }
public DeadPlayerInfo(BasePlayer victim, HitInfo info) { UserId = victim.userID.ToString(); Name = victim.displayName; Reason = victim.lastDamage.ToString(); if (info != null) { var attacker = info.Initiator as BasePlayer; if (info.Initiator) { Reason = info.Initiator.LookupPrefabName(); if (attacker && attacker != victim) Reason = attacker.displayName; } } Position = new LocationInfo(victim.transform.position); }
public bool Check() { var hit = Dependency.Resolve<ILocalCache>().Get<object>(this.CacheKey) as HitInfo; if (hit == null) { hit = new HitInfo { Counter = 1 }; Dependency.Resolve<ILocalCache>().Add(this.CacheKey, hit, this.Duration); } else { if (hit.Counter++ >= this.Limit) return false; } return true; }
public bool Check() { var hit = LocalCache.TryGet<HitInfo>(this.CacheKey); if (hit == null) { hit = new HitInfo { Counter = 1 }; LocalCache.Add(this.CacheKey, hit, this.Duration); } else { if (hit.Counter++ >= this.Limit) return false; } return true; }
public override void Kick(PhysicsObject target) { if(m_kickTime>0)return; if (target.GetExtents().min.x-GetComponent<Collider2D>().bounds.max.x > HitRange) { PushForward(0.5f); } else { HitInfo info = new HitInfo(); info.hitEnergy = m_kickEnergy; target.OnHit(info); rigidbody2D.velocity = -transform.right.normalized; m_kickTime = m_kickCooldown; } }
/// <summary> /// Create a new hitbox with new data. /// </summary> /// <param name="senders">Characters who sent the attackValue.</param> /// <param name="hitInfo">HitInfo to pass along to the reciever's Health.</param> /// <param name="time">How long the hitbox should last.</param> /// <param name="hitNumber">How many hits to perform. Usually 1.</param> /// <param name="oneShot">Does the hitbox get destroyed after landing one hit?</param> public void Initialize(List<Character> senders, HitInfo hitInfo, float time, int hitNumber, bool oneShot = false) { this.senders = senders; this.hitInfo = hitInfo; this.oneShot = oneShot; tag = senders[0].gameObject.tag; SetHitID(); if (hitNumber > 1) { StartCoroutine(MultiHit(time, hitNumber)); } //hitInfo.FactorAttackStats(senders.Select(s => s.myStats)); InvokeMethod("End", time); }
public static bool Check(ThrottleLimit limit) { var cache = HostingEnvironment.Cache; var cacheKey = limit.CacheKey; var hit = (HitInfo)(cache[cacheKey]); if (hit == null) { hit = new HitInfo { Counter = 1 }; cache.Add(cacheKey, hit, null, DateTime.Now.Add(limit.Duration), Cache.NoSlidingExpiration, System.Web.Caching.CacheItemPriority.BelowNormal, null); } else { if (hit.Counter++ > limit.Limit) return false; } return true; }
void OnEntityTakeDamage(BaseCombatEntity entity, HitInfo hitInfo) { var tick = DateTime.Now; try { if (!hitInfo.damageTypes.Has(Rust.DamageType.Decay)) return; var block = entity as BuildingBlock; if (entity.LookupShortPrefabName().StartsWith("campfire_deployed")) ProcessCampfireDamage(hitInfo); else if (block != null) ProcessBuildingDamage(block, hitInfo); else Puts($"Unsupported decaying entity detected: {entity.LookupShortPrefabName()} --- please notify author"); } finally { var ms = (DateTime.Now - tick).TotalMilliseconds; if (ms > 10) Puts($"NoDecay.OnEntityTakeDamage took {ms} ms to execute."); } }
protected override void PrimaryFire() { for (int i = 0; i < pelletCount; i++) { RaycastHit hit; //for raycast hit Quaternion fireRot = Quaternion.LookRotation(transform.forward); Quaternion randomRot = Random.rotation; fireRot = Quaternion.RotateTowards(fireRot, randomRot, Random.Range(0.0f, spreadAngle)); if (Physics.SphereCast(transform.position,0.05f, fireRot * Vector3.forward, out hit, Mathf.Infinity)) { HitInfo hitInfo = new HitInfo(); hitInfo.damage = damage; hitInfo.raycastHit = hit; hitInfo.bulletForce = _bulletForce; hitInfo.shooterPos = gameObject.transform.position; SpawnFakeBullet(hitInfo); // hit.collider.gameObject.SendMessage("GunHitInfo", hitInfo, SendMessageOptions.DontRequireReceiver); SpawnParticles(hitInfo); } } }
protected override void PrimaryFire() { RaycastHit hit; //Basic firing stuff, should have NO recoil, but in case of recoil, Quaternion fireRot = Quaternion.LookRotation(transform.forward); Quaternion randomRot = Random.rotation; float currentSpread = bulletSpreadCurve.Evaluate(fireTime / timeTillMaxSpreadAngle) * maxBulletSpreadAngle; //Uses curves to determine accuracy while firing fireRot = Quaternion.RotateTowards(fireRot, randomRot, Random.Range(0.0f, currentSpread)); if (Physics.SphereCast(transform.position,0.05f, fireRot * Vector3.forward, out hit, Mathf.Infinity)) { HitInfo lexHit = new HitInfo(); lexHit.damage = damage; lexHit.raycastHit = hit; lexHit.shooterPos = gameObject.transform.position; lexHit.bulletForce = _bulletForce; // hit.collider.gameObject.SendMessage("GunHitInfo", hitInfo, SendMessageOptions.DontRequireReceiver); SpawnParticles(lexHit); SpawnFakeBullet(lexHit); Debug.Log(lexHit.raycastHit.collider.gameObject.name); } }
protected override void PrimaryFire() { RaycastHit hit; //Bullet recoil stuff (DIFFERENT FROM SHOTGUNS) Quaternion fireRot = Quaternion.LookRotation(transform.forward); Quaternion randomRot = Random.rotation; float currentSpread = bulletSpreadCurve.Evaluate(fireTime / timeTillMaxSpreadAngle) * maxBulletSpreadAngle; //uses curve to change gun's accuracy while firing fireRot = Quaternion.RotateTowards(fireRot, randomRot, Random.Range(0.0f, currentSpread)); if (Physics.SphereCast(transform.position,0.05f, fireRot * Vector3.forward, out hit, Mathf.Infinity)) //EDIT { HitInfo hitInfo = new HitInfo(); hitInfo.damage = damage; hitInfo.raycastHit = hit; hitInfo.bulletForce = _bulletForce; hitInfo.shooterPos = gameObject.transform.position; //hit.collider.gameObject.SendMessage("GunHitInfo", hitInfo, SendMessageOptions.DontRequireReceiver); SpawnParticles(hitInfo); SpawnFakeBullet(hitInfo); // DrawLine(hitInfo); //if(hit.collider.gameObject.GetComponent<NormalZombie>()) } }
private static bool IsRadiation(HitInfo hit) => hit.damageTypes.GetMajorityDamageType() == DamageType.Radiation || (!hit.damageTypes.IsBleedCausing() && hit.damageTypes.Has(DamageType.Radiation));
private static void DoSendMouseEvents(int skipRTCameras) { Vector3 mousePosition = Input.mousePosition; int allCamerasCount = Camera.allCamerasCount; if ((m_Cameras == null) || (m_Cameras.Length != allCamerasCount)) { m_Cameras = new Camera[allCamerasCount]; } Camera.GetAllCameras(m_Cameras); for (int i = 0; i < m_CurrentHit.Length; i++) { m_CurrentHit[i] = new HitInfo(); } if (!s_MouseUsed) { foreach (Camera camera in m_Cameras) { if (((camera != null) && ((skipRTCameras == 0) || (camera.targetTexture == null))) && camera.pixelRect.Contains(mousePosition)) { GUILayer component = camera.GetComponent <GUILayer>(); if (component != null) { GUIElement element = component.HitTest(mousePosition); if (element != null) { m_CurrentHit[0].target = element.gameObject; m_CurrentHit[0].camera = camera; } else { m_CurrentHit[0].target = null; m_CurrentHit[0].camera = null; } } if (camera.eventMask != 0) { Ray ray = camera.ScreenPointToRay(mousePosition); float z = ray.direction.z; float distance = !Mathf.Approximately(0f, z) ? Mathf.Abs((float)((camera.farClipPlane - camera.nearClipPlane) / z)) : float.PositiveInfinity; GameObject obj2 = camera.RaycastTry(ray, distance, camera.cullingMask & camera.eventMask); if (obj2 != null) { m_CurrentHit[1].target = obj2; m_CurrentHit[1].camera = camera; } else if ((camera.clearFlags == CameraClearFlags.Skybox) || (camera.clearFlags == CameraClearFlags.Color)) { m_CurrentHit[1].target = null; m_CurrentHit[1].camera = null; } GameObject obj3 = camera.RaycastTry2D(ray, distance, camera.cullingMask & camera.eventMask); if (obj3 != null) { m_CurrentHit[2].target = obj3; m_CurrentHit[2].camera = camera; } else if ((camera.clearFlags == CameraClearFlags.Skybox) || (camera.clearFlags == CameraClearFlags.Color)) { m_CurrentHit[2].target = null; m_CurrentHit[2].camera = null; } } } } } for (int j = 0; j < m_CurrentHit.Length; j++) { SendEvents(j, m_CurrentHit[j]); } s_MouseUsed = false; }
bool SimulateProjectile(FiredProjectile firedProjectile, float dt) { if (firedProjectile.travelTime == 0) { dt = Time.realtimeSinceStartup - firedProjectile.firedTime; } else if (firedProjectile.travelTime > 8.0f) { return(false); } Vector3 gravity = UnityEngine.Physics.gravity * firedProjectile.projectilePrefab.gravityModifier; Vector3 oldPosition = firedProjectile.position; firedProjectile.position += firedProjectile.velocity * dt; firedProjectile.velocity += gravity * dt; firedProjectile.velocity -= firedProjectile.velocity * firedProjectile.projectilePrefab.drag * dt; firedProjectile.travelTime += dt; //Line(andrew, oldPosition, firedProjectile.position, (toggle) ? Color.red : Color.blue, 1); toggle = !toggle; Vector3 vec = firedProjectile.position - oldPosition; var list = new List <RaycastHit>(); GamePhysics.TraceAll(new Ray(oldPosition, vec), 0f, list, vec.magnitude, 1219701521, QueryTriggerInteraction.Ignore); bool didntHit = true; foreach (var hit in list) { BaseEntity ent = hit.GetEntity(); didntHit = false; HitInfo hitInfo = new HitInfo(); hitInfo.ProjectilePrefab = firedProjectile.projectilePrefab; hitInfo.Initiator = firedProjectile.owner.Get(true); hitInfo.HitEntity = ent; hitInfo.HitPositionWorld = hit.point; hitInfo.HitNormalWorld = hit.normal; hitInfo.PointStart = firedProjectile.initialPosition; hitInfo.ProjectileDistance = (firedProjectile.position - firedProjectile.initialPosition).magnitude; hitInfo.ProjectilePrefab.CalculateDamage(hitInfo, firedProjectile.projectileModifier, 1); firedProjectile.itemMod.ServerProjectileHit(hitInfo); Effect.server.ImpactEffect(hitInfo); if (ent == null) { return(false); } ent.OnAttacked(hitInfo); if (ent.ShouldBlockProjectiles()) { break; } } return(didntHit); }
///////////////////////////////////////////////////////////////////////////////////////////////////////////// object OnEntityTakeDamage(BaseCombatEntity entity, HitInfo hitInfo) { if ((entity.name.Contains("foundation")) & (!entity.name.Contains("triangle")) & (!entity.name.Contains("steps"))) { if ((ProtectFoundation == true) & (entity is BuildingBlock)) { return(false); } } if (entity.name.Contains("foundation.triangle")) { if ((ProtectFoundationTriangle == true) & (entity is BuildingBlock)) { return(false); } } if (entity.name.Contains("foundation.steps")) { if ((ProtectFoundationSteps == true) & (entity is BuildingBlock)) { return(false); } } if (entity.name.Contains("wall.window")) { if ((ProtectWindowWall == true) & (entity is BuildingBlock)) { return(false); } } if (entity.name.Contains("wall.doorway")) { if ((ProtectDoorway == true) & (entity is BuildingBlock)) { return(false); } } if ((entity.name.Contains("floor")) & (!entity.name.Contains("triangle"))) { if ((ProtectFloor == true) & (entity is BuildingBlock)) { return(false); } } if (entity.name.Contains("floor.triangle")) { if ((ProtectFloorTriangle == true) & (entity is BuildingBlock)) { return(false); } } if (entity.name.Contains("pillar")) { if ((ProtectPillar == true) & (entity is BuildingBlock)) { return(false); } } if (entity.name.Contains("stairs.l")) { if ((ProtectStairsLShaped == true) & (entity is BuildingBlock)) { return(false); } } if (entity.name.Contains("stairs.u")) { if ((ProtectStairsUShaped == true) & (entity is BuildingBlock)) { return(false); } } if (entity.name.Contains("roof")) { if ((ProtectRoof == true) & (entity is BuildingBlock)) { return(false); } } if (entity.name.Contains("wall.low")) { if ((ProtectLowWall == true) & (entity is BuildingBlock)) { return(false); } } if ((entity.name.Contains("wall")) & (!entity.name.Contains("wall.low")) & (!entity.name.Contains("wall.doorway")) & (!entity.name.Contains("wall.window"))) { if ((ProtectWall == true) & (entity is BuildingBlock)) { return(false); } } if (entity.name.Contains("wall.frame")) { if ((ProtectWallFrame == true) & (entity is BuildingBlock)) { return(false); } } if (entity.name.Contains("floor.frame")) { if ((ProtectFloorFrame == true) & (entity is BuildingBlock)) { return(false); } } return(null); }
private object IOnBaseCombatEntityHurt(BaseCombatEntity entity, HitInfo hitInfo) { return(entity is BasePlayer ? null : Interface.CallHook("OnEntityTakeDamage", entity, hitInfo)); }
private void OnKilledByEnt(BaseEntity attacker, BasePlayer victim, HitInfo hitInfo) { _killQueue.OnDeath(victim, null, string.Format(_($"MsgFeedKill{attacker.GetType()}"), SanitizeName(victim.displayName))); }
void OnEntityTakeDamage(BaseEntity entity, HitInfo info) { var target = entity.PrefabName; var attacker = info.Initiator; if (purgeActive) { var player = entity.ToPlayer(); if (player != null && !permission.UserHasPermission(player.UserIDString, permProtect)) { return; } if (purgeAnimal && (target.Contains("animals") || target.Contains("corpse") || (attacker != null && attacker.name.Contains("animals")))) { return; } if (purgeHeli && (entity is BaseHelicopter || attacker is BaseHelicopter)) { return; } if (purgeLoot && (target.Contains("loot") || target.Contains("box") || target.Contains("barrel"))) { return; } if (purgeMonumentBarricade && target.Contains("door barricades")) { return; } if (purgeStructure && attacker != null && (entity is Barricade || entity is BuildingBlock || entity is Door || entity is SimpleBuildingBlock)) { return; } if (purgeTrap && entity is BasePlayer && (attacker is Barricade || attacker is BaseTrap || attacker.PrefabName.Contains("wall.external.high"))) { return; } if (purgeTurret && (entity is AutoTurret || attacker is AutoTurret || entity is FlameTurret || attacker is FlameTurret)) { return; } if (purgeWorld && (entity is BasePlayer && attacker == null)) { return; } } else { var owner = attacker?.ToPlayer(); if (owner != null && entity.OwnerID == owner.userID) { return; } if (safeAnimal && (target.Contains("animals") || target.Contains("corpse") || (attacker != null && attacker.name.Contains("animals")))) { return; } if (safeHeli && (entity is BaseHelicopter || attacker is BaseHelicopter)) { return; } if (safeLoot && (target.Contains("loot") || target.Contains("box") || target.Contains("barrel"))) { return; } if (safeMonumentBarricade && target.Contains("door barricades")) { return; } if (safeSelf && entity == attacker) { return; } if (safeStructure && attacker != null && (entity is Barricade || entity is BuildingBlock || entity is Door || entity is SimpleBuildingBlock)) { return; } if (safeTrap && entity is BasePlayer && (attacker is Barricade || attacker is BaseTrap || attacker.PrefabName.Contains("wall.external.high"))) { return; } if (safeTurret && (entity is AutoTurret || attacker is AutoTurret || entity is FlameTurret || attacker is FlameTurret)) { return; } if (safeWorld && (entity is BasePlayer && attacker == null)) { return; } } info.damageTypes = new DamageTypeList(); info.PointStart = Vector3.zero; info.HitMaterial = 0; }
private object IOnBasePlayerHurt(BasePlayer basePlayer, HitInfo hitInfo) { return(isPlayerTakingDamage ? null : Interface.CallHook("OnEntityTakeDamage", basePlayer, hitInfo)); }
static void DoSendMouseEvents(int skipRTCameras) { UpdateMouse(); var mousePosition = s_MousePosition; int camerasCount = Camera.allCamerasCount; if (m_Cameras == null || m_Cameras.Length != camerasCount) { m_Cameras = new Camera[camerasCount]; } // Fetch all cameras. Camera.GetAllCameras(m_Cameras); // Clear the HitInfos from last time for (var hitIndex = 0; hitIndex < m_CurrentHit.Length; ++hitIndex) { m_CurrentHit[hitIndex] = new HitInfo(); } // If UnityGUI has the mouse over, we simply don't do any mouse hit detection. // That way, it will appear as if the mouse has missed everything. if (!s_MouseUsed) { foreach (var camera in m_Cameras) { // we do not want to check cameras that are rendering to textures, starting with 4.0 if (camera == null || skipRTCameras != 0 && camera.targetTexture != null) { continue; } int displayIndex = camera.targetDisplay; var eventPosition = Display.RelativeMouseAt(mousePosition); if (eventPosition != Vector3.zero) { // We support multiple display and display identification based on event position. int eventDisplayIndex = (int)eventPosition.z; // Discard events that are not part of this display so the user does not interact with multiple displays at once. if (eventDisplayIndex != displayIndex) { continue; } // Multiple display support only when not the main display. For display 0 the reported // resolution is always the desktop resolution since it's part of the display API, // so we use the standard non multiple display method. float w = Screen.width; float h = Screen.height; if (displayIndex > 0 && displayIndex < Display.displays.Length) { w = Display.displays[displayIndex].systemWidth; h = Display.displays[displayIndex].systemHeight; } Vector2 pos = new Vector2(eventPosition.x / w, eventPosition.y / h); // If the mouse is outside the display bounds, do nothing if (pos.x < 0f || pos.x > 1f || pos.y < 0f || pos.y > 1f) { continue; } } else { // The multiple display system is not supported on all platforms, when it is not supported the returned position // will be all zeros so when the returned index is 0 we will default to the mouse position to be safe. eventPosition = mousePosition; if (Display.activeEditorGameViewTarget != displayIndex) { continue; } eventPosition.z = Display.activeEditorGameViewTarget; } // Is the mouse inside the cameras viewport? var rect = camera.pixelRect; if (!rect.Contains(eventPosition)) { continue; } // There is no need to continue if the camera shouldn't be sending out events if (camera.eventMask == 0) { continue; } // Calculate common physics projection and distance. var screenProjectionRay = camera.ScreenPointToRay(eventPosition); var projectionDirection = screenProjectionRay.direction.z; var distanceToClipPlane = Mathf.Approximately(0.0f, projectionDirection) ? Mathf.Infinity : Mathf.Abs((camera.farClipPlane - camera.nearClipPlane) / projectionDirection); // Did we hit any 3D colliders? var hit3D = CameraRaycastHelper.RaycastTry(camera, screenProjectionRay, distanceToClipPlane, camera.cullingMask & camera.eventMask); if (hit3D != null) { m_CurrentHit[m_HitIndexPhysics3D].target = hit3D; m_CurrentHit[m_HitIndexPhysics3D].camera = camera; } // We did not hit anything with a raycast from this camera. But our camera // clears the screen and renders on top of whatever was below, thus making things // rendered before invisible. So clear any previous hit we have found. else if (camera.clearFlags == CameraClearFlags.Skybox || camera.clearFlags == CameraClearFlags.SolidColor) { m_CurrentHit[m_HitIndexPhysics3D].target = null; m_CurrentHit[m_HitIndexPhysics3D].camera = null; } // Did we hit any 2D colliders? var hit2D = CameraRaycastHelper.RaycastTry2D(camera, screenProjectionRay, distanceToClipPlane, camera.cullingMask & camera.eventMask); if (hit2D != null) { m_CurrentHit[m_HitIndexPhysics2D].target = hit2D; m_CurrentHit[m_HitIndexPhysics2D].camera = camera; } // We did not hit anything with a raycast from this camera. But our camera // clears the screen and renders on top of whatever was below, thus making things // rendered before invisible. So clear any previous hit we have found. else if (camera.clearFlags == CameraClearFlags.Skybox || camera.clearFlags == CameraClearFlags.SolidColor) { m_CurrentHit[m_HitIndexPhysics2D].target = null; m_CurrentHit[m_HitIndexPhysics2D].camera = null; } } } // Send hit events. for (var hitIndex = 0; hitIndex < m_CurrentHit.Length; ++hitIndex) { SendEvents(hitIndex, m_CurrentHit[hitIndex]); } s_MouseUsed = false; }
public AggressiveAction(HitInfo info) { if (info == null) { return; } // Get the source of the aggression if (info.Initiator != null) { if (info.InitiatorPlayer != null) { aggression_initiator = new Resident(info.InitiatorPlayer); } else { aggression_initiator = new Entity(info.Initiator); } } // Get the target of the agression BasePlayer player = info.HitEntity?.GetComponent <BasePlayer>(); if (player != null) { aggression_target = new Resident(player); } else if (info.HitEntity != null) { aggression_target = new Entity(info.HitEntity); } // Get the weapons name if (info.Weapon.ShortPrefabName != null) { weapon_name = info.Weapon.ShortPrefabName; weapon_prefab = info.Weapon.PrefabName; } if (info.material != null) { material_name = info.material.name; } if (info.hasDamage) { damage_name = info.damageProperties.name; damage_type = info.damageTypes.GetMajorityDamageType().ToString(); damage_delt = (int)info.damageTypes.Total(); is_attack = info.damageTypes.IsConsideredAnAttack(); } did_gather = info.DidGather; is_headshot = info.isHeadshot; if (info.IsProjectile()) { is_projectile = info.IsProjectile(); projectile_distance = info.ProjectileDistance; } }
private static bool IsFlame(HitInfo hit) => hit.damageTypes.GetMajorityDamageType() == DamageType.Heat || (!hit.damageTypes.IsBleedCausing() && hit.damageTypes.Has(DamageType.Heat));
private object OnMeleeAttack(BaseMelee melee, HitInfo hitinfo) { return(Interface.CallHook("OnPlayerAttack", melee.ownerPlayer, hitinfo)); }
public HurtEvent(HitInfo info) { _info = info; }
/****************************************************** ** Multi Resident Event Serializable Object Classes ** ******************************************************/ // On Player Attack // Useful for modifying an attack before it goes out hitInfo.HitEntity should be the void OnPlayerAttack(BasePlayer attacker, HitInfo info) { CreateLogEntry("on_player_attack.log", new ResidentAttack(attacker, info)); }
void CreateReplenishableContainer(BasePlayer player, ReplenishPlayer rPlayer, StorageContainer container, HitInfo info, string type) { if (GetReplenishableContainer(container.inventory) != null) { containers.Remove(GetReplenishableContainer(container.inventory)); ReplyPlayer(player, "AlreadyReplenishing"); } ReplenishableContainer repl = new ReplenishableContainer(container.inventory.uid, rPlayer.timer); repl.type = Lang(type); repl.SaveItems(container.inventory); var worldPos = info.HitEntity.GetEstimatedWorldPosition(); repl.pos = new Pos(worldPos.x, worldPos.y, worldPos.z); containers.Add(repl); ReplyFormatted(player, String.Format(Lang("BoxAdded"), repl.type, repl.uid, repl.timer)); }
// On Player Death // Called when the player is about to die. HitInfo may be null sometimes object OnPlayerDeath(BasePlayer player, HitInfo info) { CreateLogEntry("on_player_death.log", new ResidentDead(player, info)); return(null); }
private static bool IsExplosion(HitInfo hit) => (hit.WeaponPrefab != null && (hit.WeaponPrefab.ShortPrefabName.Contains("grenade") || hit.WeaponPrefab.ShortPrefabName.Contains("explosive"))) || hit.damageTypes.GetMajorityDamageType() == DamageType.Explosion || (!hit.damageTypes.IsBleedCausing() && hit.damageTypes.Has(DamageType.Explosion));
public override void OnSuccessfulHit(HitInfo info) { FSMUtility.SendEventToGameObject(info.Attacker, "HIT LANDED", false); }
internal override void OnEventPlayerDeath(EventManager.BaseEventPlayer victim, EventManager.BaseEventPlayer attacker = null, HitInfo hitInfo = null) { if (victim == null) { return; } victim.OnPlayerDeath(attacker, Configuration.RespawnTime); if (attacker != null && victim != attacker) { if (Configuration.ResetHealthOnKill) { attacker.Player.health = attacker.Player.MaxHealth(); attacker.Player.SendNetworkUpdate(BasePlayer.NetworkQueue.Update); } attacker.OnKilledPlayer(hitInfo); string attackersWeapon = GetWeaponShortname(hitInfo); if (!string.IsNullOrEmpty(attackersWeapon)) { if (KilledByRankedWeapon(attacker as GunGamePlayer, attackersWeapon)) { (attacker as GunGamePlayer).Rank += 1; if ((attacker as GunGamePlayer).Rank > weaponSet.Count) { winner = attacker; InvokeHandler.Invoke(this, EndEvent, 0.1f); return; } else { (attacker as GunGamePlayer).RemoveRankWeapon(); (attacker as GunGamePlayer).GiveRankWeapon(weaponSet.CreateItem((attacker as GunGamePlayer).Rank)); } } else if (KilledByDowngradeWeapon(attackersWeapon)) { (victim as GunGamePlayer).Rank = Mathf.Clamp((victim as GunGamePlayer).Rank - 1, 1, weaponSet.Count); } } } UpdateScoreboard(); base.OnEventPlayerDeath(victim, attacker); }
public bool ShouldReportEvent(WebInterface.ACTION_BUTTON buttonId, HitInfo hit) { return(IsAtHoverDistance(hit.distance) && (model.button == "ANY" || buttonId.ToString() == model.button)); }
public override void OnKilled(HitInfo info) { this.DropItems(); base.OnKilled(info); }
public static void ImpactEffect(HitInfo info) { Vector3 vector3; string str = StringPool.Get(info.HitMaterial); string particle = EffectDictionary.GetParticle(info.damageTypes.GetMajorityDamageType(), str); string decal = EffectDictionary.GetDecal(info.damageTypes.GetMajorityDamageType(), str); if (TerrainMeta.WaterMap != null && info.HitMaterial != Projectile.WaterMaterialID() && info.HitMaterial != Projectile.FleshMaterialID() && info.HitPositionWorld.y < TerrainMeta.WaterMap.GetHeight(info.HitPositionWorld)) { return; } if (!info.HitEntity.IsValid()) { Vector3 hitPositionWorld = info.HitPositionWorld; Vector3 hitNormalWorld = info.HitNormalWorld; vector3 = new Vector3(); Effect.client.Run(particle, hitPositionWorld, hitNormalWorld, vector3); Vector3 hitPositionWorld1 = info.HitPositionWorld; Vector3 hitNormalWorld1 = info.HitNormalWorld; vector3 = new Vector3(); Effect.client.Run(decal, hitPositionWorld1, hitNormalWorld1, vector3); } else { GameObjectRef impactEffect = info.HitEntity.GetImpactEffect(info); if (impactEffect.isValid) { particle = impactEffect.resourcePath; } Effect.client.Run(particle, info.HitEntity, info.HitBone, info.HitPositionLocal, info.HitNormalLocal); if (info.DoDecals) { Effect.client.Run(decal, info.HitEntity, info.HitBone, info.HitPositionLocal, info.HitNormalLocal); } } if (info.WeaponPrefab) { BaseMelee weaponPrefab = info.WeaponPrefab as BaseMelee; if (weaponPrefab != null) { string strikeEffectPath = weaponPrefab.GetStrikeEffectPath(str); if (!info.HitEntity.IsValid()) { Vector3 vector31 = info.HitPositionWorld; Vector3 hitNormalWorld2 = info.HitNormalWorld; vector3 = new Vector3(); Effect.client.Run(strikeEffectPath, vector31, hitNormalWorld2, vector3); } else { Effect.client.Run(strikeEffectPath, info.HitEntity, info.HitBone, info.HitPositionLocal, info.HitNormalLocal); } } } if (info.damageTypes.Has(DamageType.Explosion)) { Effect.client.DoAdditiveImpactEffect(info, "assets/bundled/prefabs/fx/impacts/additive/explosion.prefab"); } if (info.damageTypes.Has(DamageType.Heat)) { Effect.client.DoAdditiveImpactEffect(info, "assets/bundled/prefabs/fx/impacts/additive/fire.prefab"); } }
public static bool Compare(HitInfo lhs, HitInfo rhs) { return(lhs.target == rhs.target && lhs.camera == rhs.camera); }
public void PlayerDamage(HitInfo info) { //playerDamage[playerid].SetTrigger("Do It"); }
private void OnEntityTakeDamage(BaseCombatEntity entity, HitInfo info) { HookCalled("OnEntityTakeDamage"); }
void CancelDamage(HitInfo hitinfo) { hitinfo.damageTypes = emptyDamageType; hitinfo.DoHitEffects = false; hitinfo.HitMaterial = 0; }
private void OnEntityDeath(BaseCombatEntity entity, HitInfo hitInfo) { HookCalled("OnEntityDeath"); // TODO: Print player died // TODO: Automatically respawn admin after X time }
private void OnHammerHit(BasePlayer player, HitInfo info) { HookCalled("OnHammerHit"); }
/// <summary> /// OnHammerHit for this player /// </summary> public static void OnHammerHit(BasePlayer basePlayer, HitInfo hit) => Get(basePlayer).OnHammerHit(hit);
public override void OnAttacked(HitInfo info) { base.OnAttacked(info); this.Alert(); }