C# HitInfo类代码示例

 public BuildingPartDestroyedEvent(BuildingBlock buildingBlock, HitInfo info)
 {
     BuildingPart = new BuildingPart(buildingBlock);
     Info = info;
     string bonename = StringPool.Get(info.HitBone);
     HitBone = bonename == "" ? "unknown" : bonename;
 }

 private EventManager()
 {
     this.initializedFlag = false;
     this.initializedListener = null;
     this.hitInfoListener = null;
     this.lastHitInfo = null;
 }

	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

			}
		}
		
	}

	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));
	}

    /// <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));
        }
    }

 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 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 HammerEvent(HitInfo info, BasePlayer player)
 {
     _info = info;
     basePlayer = player;
     string bonename = StringPool.Get(info.HitBone);
     HitBone = bonename == "" ? "unknown" : bonename;
 }

	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;
        }