根据向量相似度分析，与 'TickInterval, Projectile, Verse' 最相关的代码定义如下：

---
**文件路径 (精确匹配):** `C:\Steam\steamapps\common\RimWorld\Data\dll1.6\Verse\Projectile.txt`

```csharp
public abstract class Projectile : ThingWithComps
{
	private static readonly Material shadowMaterial = MaterialPool.MatFrom("Things/Skyfaller/SkyfallerShadowCircle", ShaderDatabase.Transparent);

	protected Vector3 origin;

	protected Vector3 destination;

	public LocalTargetInfo usedTarget;

	public LocalTargetInfo intendedTarget;

	protected Thing equipment;

	protected ThingDef equipmentDef;

	protected Thing launcher;

	protected ThingDef targetCoverDef;

	private ProjectileHitFlags desiredHitFlags = ProjectileHitFlags.All;

	protected bool preventFriendlyFire;

	protected int lifetime;

	protected QualityCategory equipmentQuality = QualityCategory.Normal;

	public float stoppingPower;

	public DamageDef damageDefOverride;

	public List<ExtraDamage> extraDamages = new List<ExtraDamage>();

	protected bool landed;

	protected int ticksToImpact;

	private Sustainer ambientSustainer;

	private static List<IntVec3> checkedCells = new List<IntVec3>();

	public DamageDef DamageDef => damageDefOverride ?? def.projectile.damageDef;

	public IEnumerable<ExtraDamage> ExtraDamages
	{
		get
		{
			List<ExtraDamage> first = extraDamages;
			IEnumerable<ExtraDamage> enumerable = def.projectile.extraDamages;
			return first.Concat(enumerable ?? Enumerable.Empty<ExtraDamage>());
		}
	}

	public ProjectileHitFlags HitFlags
	{
		get
		{
			if (def.projectile.alwaysFreeIntercept)
			{
				return ProjectileHitFlags.All;
			}
			if (def.projectile.flyOverhead)
			{
				return ProjectileHitFlags.None;
			}
			return desiredHitFlags;
		}
		set
		{
			desiredHitFlags = value;
		}
	}

	protected float StartingTicksToImpact
	{
		get
		{
			float num = (origin - destination).magnitude / def.projectile.SpeedTilesPerTick;
			if (num <= 0f)
			{
				num = 0.001f;
			}
			return num;
		}
	}

	protected IntVec3 DestinationCell => new IntVec3(destination);

	public virtual Vector3 ExactPosition
	{
		get
		{
			Vector3 vector = (destination - origin).Yto0() * DistanceCoveredFraction;
			return origin.Yto0() + vector + Vector3.up * def.Altitude;
		}
	}

	protected float DistanceCoveredFraction => Mathf.Clamp01(1f - (float)ticksToImpact / StartingTicksToImpact);

	protected float DistanceCoveredFractionArc => Mathf.Clamp01(1f - (float)(landed ? lifetime : ticksToImpact) / StartingTicksToImpact);

	public virtual Quaternion ExactRotation => Quaternion.LookRotation((destination - origin).Yto0());

	public virtual bool AnimalsFleeImpact => false;

	public override Vector3 DrawPos => ExactPosition;

	public virtual Material DrawMat => def.graphic.MatSingleFor(this);

	public virtual int DamageAmount => def.projectile.GetDamageAmount(equipment);

	public virtual float ArmorPenetration => def.projectile.GetArmorPenetration(equipment);

	public ThingDef EquipmentDef => equipmentDef;

	public Thing Launcher => launcher;

	public override int UpdateRateTicks
	{
		get
		{
			if (base.Spawned && Find.CurrentMap == base.Map && Find.CameraDriver.InViewOf(this))
			{
				return 1;
			}
			return 15;
		}
	}

	private float ArcHeightFactor
	{
		get
		{
			float num = def.projectile.arcHeightFactor;
			float num2 = (destination - origin).MagnitudeHorizontalSquared();
			if (num * num > num2 * 0.2f * 0.2f)
			{
				num = Mathf.Sqrt(num2) * 0.2f;
			}
			return num;
		}
	}

	public override void ExposeData()
	{
		base.ExposeData();
		Scribe_Values.Look(ref origin, "origin");
		Scribe_Values.Look(ref destination, "destination");
		Scribe_Values.Look(ref ticksToImpact, "ticksToImpact", 0);
		Scribe_TargetInfo.Look(ref usedTarget, "usedTarget");
		Scribe_TargetInfo.Look(ref intendedTarget, "intendedTarget");
		Scribe_References.Look(ref launcher, "launcher");
		Scribe_References.Look(ref equipment, "equipment");
		Scribe_Defs.Look(ref equipmentDef, "equipmentDef");
		Scribe_Defs.Look(ref targetCoverDef, "targetCoverDef");
		Scribe_Values.Look(ref desiredHitFlags, "desiredHitFlags", ProjectileHitFlags.All);
		Scribe_Values.Look(ref preventFriendlyFire, "preventFriendlyFire", defaultValue: false);
		Scribe_Values.Look(ref landed, "landed", defaultValue: false);
		Scribe_Values.Look(ref lifetime, "lifetime", 0);
		Scribe_Values.Look(ref equipmentQuality, "equipmentQuality", QualityCategory.Normal);
	}

	public void Launch(Thing launcher, LocalTargetInfo usedTarget, LocalTargetInfo intendedTarget, ProjectileHitFlags hitFlags, bool preventFriendlyFire = false, Thing equipment = null)
	{
		Launch(launcher, base.Position.ToVector3Shifted(), usedTarget, intendedTarget, hitFlags, preventFriendlyFire, equipment);
	}

	public virtual void Launch(Thing launcher, Vector3 origin, LocalTargetInfo usedTarget, LocalTargetInfo intendedTarget, ProjectileHitFlags hitFlags, bool preventFriendlyFire = false, Thing equipment = null, ThingDef targetCoverDef = null)
	{
		this.launcher = launcher;
		this.origin = origin;
		this.usedTarget = usedTarget;
		this.intendedTarget = intendedTarget;
		this.targetCoverDef = targetCoverDef;
		this.preventFriendlyFire = preventFriendlyFire;
		HitFlags = hitFlags;
		stoppingPower = def.projectile.stoppingPower;
		if (stoppingPower == 0f && def.projectile.damageDef != null)
		{
			stoppingPower = def.projectile.damageDef.defaultStoppingPower;
		}
		if (equipment != null)
		{
			this.equipment = equipment;
			equipmentDef = equipment.def;
			equipment.TryGetQuality(out equipmentQuality);
			if (equipment.TryGetComp(out CompUniqueWeapon comp))
			{
				foreach (WeaponTraitDef item in comp.TraitsListForReading)
				{
					if (!Mathf.Approximately(item.additionalStoppingPower, 0f))
					{
						stoppingPower += item.additionalStoppingPower;
					}
				}
			}
		}
		else
		{
			equipmentDef = null;
		}
		destination = usedTarget.Cell.ToVector3Shifted() + Gen.RandomHorizontalVector(0.3f);
		ticksToImpact = Mathf.CeilToInt(StartingTicksToImpact);
		if (ticksToImpact < 1)
		{
			ticksToImpact = 1;
		}
		lifetime = ticksToImpact;
		if (!def.projectile.soundAmbient.NullOrUndefined())
		{
			ambientSustainer = def.projectile.soundAmbient.TrySpawnSustainer(SoundInfo.InMap(this, MaintenanceType.PerTick));
		}
	}

	protected override void Tick()
	{
		base.Tick();
		if (ticksToImpact == 60 && Find.TickManager.CurTimeSpeed == TimeSpeed.Normal && def.projectile.soundImpactAnticipate != null)
		{
			def.projectile.soundImpactAnticipate.PlayOneShot(this);
		}
		if (ambientSustainer != null)
		{
			ambientSustainer.Maintain();
		}
	}

	protected override void TickInterval(int delta)
	{
		base.TickInterval(delta);
		lifetime -= delta;
		if (landed)
		{
			return;
		}
		Vector3 exactPosition = ExactPosition;
		ticksToImpact -= delta;
		if (!ExactPosition.InBounds(base.Map))
		{
			ticksToImpact += delta;
			base.Position = ExactPosition.ToIntVec3();
			Destroy();
			return;
		}
		Vector3 exactPosition2 = ExactPosition;
		if (CheckForFreeInterceptBetween(exactPosition, exactPosition2))
		{
			return;
		}
		base.Position = ExactPosition.ToIntVec3();
		if (ticksToImpact <= 0)
		{
			if (DestinationCell.InBounds(base.Map))
			{
				base.Position = DestinationCell;
			}
			ImpactSomething();
		}
	}

	private bool CheckForFreeInterceptBetween(Vector3 lastExactPos, Vector3 newExactPos)
	{
		if (lastExactPos == newExactPos)
		{
			return false;
		}
		List<Thing> list = base.Map.listerThings.ThingsInGroup(ThingRequestGroup.ProjectileInterceptor);
		for (int i = 0; i < list.Count; i++)
		{
			if (list[i].TryGetComp<CompProjectileInterceptor>().CheckIntercept(this, lastExactPos, newExactPos))
			{
				Impact(null, blockedByShield: true);
				return true;
			}
		}
		IntVec3 intVec = lastExactPos.ToIntVec3();
		IntVec3 intVec2 = newExactPos.ToIntVec3();
		if (intVec2 == intVec)
		{
			return false;
		}
		if (!intVec.InBounds(base.Map) || !intVec2.InBounds(base.Map))
		{
			return false;
		}
		if (intVec2.AdjacentToCardinal(intVec))
		{
			return CheckForFreeIntercept(intVec2);
		}
		if (VerbUtility.InterceptChanceFactorFromDistance(origin, intVec2) <= 0f)
		{
			return false;
		}
		Vector3 vect = lastExactPos;
		Vector3 v = newExactPos - lastExactPos;
		Vector3 vector = v.normalized * 0.2f;
		int num = (int)(v.MagnitudeHorizontal() / 0.2f);
		checkedCells.Clear();
		int num2 = 0;
		IntVec3 intVec3;
		do
		{
			vect += vector;
			intVec3 = vect.ToIntVec3();
			if (!checkedCells.Contains(intVec3))
			{
				if (CheckForFreeIntercept(intVec3))
				{
					return true;
				}
				checkedCells.Add(intVec3);
			}
			num2++;
			if (num2 > num)
			{
				return false;
			}
		}
		while (!(intVec3 == intVec2));
		return false;
	}

	private bool CheckForFreeIntercept(IntVec3 c)
	{
		if (destination.ToIntVec3() == c)
		{
			return false;
		}
		float num = VerbUtility.InterceptChanceFactorFromDistance(origin, c);
		if (num <= 0f)
		{
			return false;
		}
		bool flag = false;
		List<Thing> thingList = c.GetThingList(base.Map);
		for (int i = 0; i < thingList.Count; i++)
		{
			Thing thing = thingList[i];
			if (!CanHit(thing))
			{
				continue;
			}
			bool flag2 = false;
			if (thing.def.Fillage == FillCategory.Full)
			{
				if (!(thing is Building_Door { Open: not false }))
				{
					ThrowDebugText("int-wall", c);
					Impact(thing);
					return true;
				}
				flag2 = true;
			}
			float num2 = 0f;
			if (thing is Pawn pawn)
			{
				num2 = 0.4f * Mathf.Clamp(pawn.BodySize, 0.1f, 2f);
				if (pawn.GetPosture() != 0)
				{
					num2 *= 0.1f;
				}
				if (launcher != null && pawn.Faction != null && launcher.Faction != null && !pawn.Faction.HostileTo(launcher.Faction))
				{
					if (preventFriendlyFire)
					{
						num2 = 0f;
						ThrowDebugText("ff-miss", c);
					}
					else
					{
						num2 *= Find.Storyteller.difficulty.friendlyFireChanceFactor;
					}
				}
			}
			else if (thing.def.fillPercent > 0.2f)
			{
				num2 = (flag2 ? 0.05f : ((!DestinationCell.AdjacentTo8Way(c)) ? (thing.def.fillPercent * 0.15f) : (thing.def.fillPercent * 1f)));
			}
			num2 *= num;
			if (num2 > 1E-05f)
			{
				if (Rand.Chance(num2))
				{
					ThrowDebugText("int-" + num2.ToStringPercent(), c);
					Impact(thing);
					return true;
				}
				flag = true;
				ThrowDebugText(num2.ToStringPercent(), c);
			}
		}
		if (!flag)
		{
			ThrowDebugText("o", c);
		}
		return false;
	}

	private void ThrowDebugText(string text, IntVec3 c)
	{
		if (DebugViewSettings.drawShooting)
		{
			MoteMaker.ThrowText(c.ToVector3Shifted(), base.Map, text);
		}
	}

	protected override void DrawAt(Vector3 drawLoc, bool flip = false)
	{
		float num = ArcHeightFactor * GenMath.InverseParabola(DistanceCoveredFractionArc);
		Vector3 vector = drawLoc + new Vector3(0f, 0f, 1f) * num;
		if (def.projectile.shadowSize > 0f)
		{
			DrawShadow(drawLoc, num);
		}
		Quaternion rotation = ExactRotation;
		if (def.projectile.spinRate != 0f)
		{
			float num2 = 60f / def.projectile.spinRate;
			rotation = Quaternion.AngleAxis((float)Find.TickManager.TicksGame % num2 / num2 * 360f, Vector3.up);
		}
		if (def.projectile.useGraphicClass)
		{
			Graphic.Draw(vector, base.Rotation, this, rotation.eulerAngles.y);
		}
		else
		{
			Graphics.DrawMesh(MeshPool.GridPlane(def.graphicData.drawSize), vector, rotation, DrawMat, 0);
		}
		Comps_PostDraw();
	}

	protected bool CanHit(Thing thing)
	{
		if (!thing.Spawned)
		{
			return false;
		}
		if (thing == launcher)
		{
			return false;
		}
		ProjectileHitFlags hitFlags = HitFlags;
		if (hitFlags == ProjectileHitFlags.None)
		{
			return false;
		}
		if (thing.Map != base.Map)
		{
			return false;
		}
		if (CoverUtility.ThingCovered(thing, base.Map))
		{
			return false;
		}
		if (thing == intendedTarget && (hitFlags & ProjectileHitFlags.IntendedTarget) != 0)
		{
			return true;
		}
		if (thing != intendedTarget)
		{
			if (thing is Pawn)
			{
				if ((hitFlags & ProjectileHitFlags.NonTargetPawns) != 0)
				{
					return true;
				}
			}
			else if ((hitFlags & ProjectileHitFlags.NonTargetWorld) != 0)
			{
				return true;
			}
		}
		if (thing == intendedTarget && thing.def.Fillage == FillCategory.Full)
		{
			return true;
		}
		return false;
	}

	protected virtual void ImpactSomething()
	{
		if (def.projectile.flyOverhead)
		{
			RoofDef roofDef = base.Map.roofGrid.RoofAt(base.Position);
			if (roofDef != null)
			{
				if (roofDef.isThickRoof)
				{
					ThrowDebugText("hit-thick-roof", base.Position);
					if (!def.projectile.soundHitThickRoof.NullOrUndefined())
					{
						def.projectile.soundHitThickRoof.PlayOneShot(new TargetInfo(base.Position, base.Map));
					}
					Destroy();
					return;
				}
				if (base.Position.GetEdifice(base.Map) == null || base.Position.GetEdifice(base.Map).def.Fillage != FillCategory.Full)
				{
					RoofCollapserImmediate.DropRoofInCells(base.Position, base.Map);
				}
			}
		}
		if (usedTarget.HasThing && CanHit(usedTarget.Thing))
		{
			if (usedTarget.Thing is Pawn p && p.GetPosture() != 0 && (origin - destination).MagnitudeHorizontalSquared() >= 20.25f && !Rand.Chance(0.5f))
			{
				ThrowDebugText("miss-laying", base.Position);
				Impact(null);
			}
			else
			{
				Impact(usedTarget.Thing);
			}
			return;
		}
		List<Thing> list = VerbUtility.ThingsToHit(base.Position, base.Map, CanHit);
		list.Shuffle();
		for (int i = 0; i < list.Count; i++)
		{
			Thing thing = list[i];
			float num;
			if (thing is Pawn pawn)
			{
				num = 0.5f * Mathf.Clamp(pawn.BodySize, 0.1f, 2f);
				if (pawn.GetPosture() != 0 && (origin - destination).MagnitudeHorizontalSquared() >= 20.25f)
				{
					num *= 0.5f;
				}
				if (launcher != null && pawn.Faction != null && launcher.Faction != null && !pawn.Faction.HostileTo(launcher.Faction))
				{
					num *= VerbUtility.InterceptChanceFactorFromDistance(origin, base.Position);
				}
			}
			else
			{
				num = 1.5f * thing.def.fillPercent;
			}
			if (Rand.Chance(num))
			{
				ThrowDebugText("hit-" + num.ToStringPercent(), base.Position);
				Impact(list.RandomElement());
				return;
			}
			ThrowDebugText("miss-" + num.ToStringPercent(), base.Position);
		}
		Impact(null);
	}

	protected virtual void Impact(Thing hitThing, bool blockedByShield = false)
	{
		GenClamor.DoClamor(this, 12f, ClamorDefOf.Impact);
		if (!blockedByShield && def.projectile.landedEffecter != null)
		{
			def.projectile.landedEffecter.Spawn(base.Position, base.Map).Cleanup();
		}
		Destroy();
	}

	private void DrawShadow(Vector3 drawLoc, float height)
	{
		if (!(shadowMaterial == null))
		{
			float num = def.projectile.shadowSize * Mathf.Lerp(1f, 0.6f, height);
			Vector3 s = new Vector3(num, 1f, num);
			Vector3 vector = new Vector3(0f, -0.01f, 0f);
			Matrix4x4 matrix = default(Matrix4x4);
			matrix.SetTRS(drawLoc + vector, Quaternion.identity, s);
			Graphics.DrawMesh(MeshPool.plane10, matrix, shadowMaterial, 0);
		}
	}
}
```
---
**文件路径:** `C:\Steam\steamapps\common\RimWorld\Data\dll1.6\RimWorld\CompRitualEffect_IntervalSpawn.txt`
**相似度:** 0.5662

```csharp
public abstract class CompRitualEffect_IntervalSpawn : RitualVisualEffectComp
{
	public int lastSpawnTick = -1;

	public int ticksPassed;

	protected int burstsDone;

	protected CompProperties_RitualEffectIntervalSpawn Props => (CompProperties_RitualEffectIntervalSpawn)props;

	public override bool ShouldSpawnNow(LordJob_Ritual ritual)
	{
		if (Props.delay > 0 && ticksPassed < Props.delay)
		{
			return false;
		}
		if (Props.maxBursts > 0 && burstsDone >= Props.maxBursts)
		{
			return false;
		}
		if (lastSpawnTick != -1)
		{
			return GenTicks.TicksGame - lastSpawnTick >= Props.spawnIntervalTicks;
		}
		return true;
	}

	public override void TickInterval(int delta)
	{
		base.TickInterval(delta);
		ticksPassed += delta;
	}

	public override void ExposeData()
	{
		base.ExposeData();
		Scribe_Values.Look(ref lastSpawnTick, "lastSpawnTick", -1);
		Scribe_Values.Look(ref burstsDone, "burstsDone", 0);
		Scribe_Values.Look(ref ticksPassed, "ticksPassed", 0);
	}
}
```
---
**文件路径:** `C:\Steam\steamapps\common\RimWorld\Data\dll1.6\Verse\Gene_Clotting.txt`
**相似度:** 0.5078

```csharp
public class Gene_Clotting : Gene
{
	private const int ClotCheckInterval = 360;

	private static readonly FloatRange TendingQualityRange = new FloatRange(0.2f, 0.7f);

	public override void TickInterval(int delta)
	{
		base.TickInterval(delta);
		if (!pawn.IsHashIntervalTick(360, delta))
		{
			return;
		}
		List<Hediff> hediffs = pawn.health.hediffSet.hediffs;
		for (int num = hediffs.Count - 1; num >= 0; num--)
		{
			if (hediffs[num].Bleeding)
			{
				hediffs[num].Tended(TendingQualityRange.RandomInRange, TendingQualityRange.TrueMax, 1);
			}
		}
	}
}
```