void Start()
{
_damageScript = GetComponent<TakeDamage>();
_controlScript = GetComponent<Controls>();
_emitter = transform.Find("Detailed Smoke").particleEmitter;
}
protected override void ProcessDamage(TakeDamage msg)
{
base.ProcessDamage(msg);
MyContainer.Tell(new ContainerNotify($"{Name} drops a chunk of flesh", Self));
var meat = Context.System.ActorOf(Props.Create(() => new Corpse("a chunk of flesh")));
meat.Tell(new SetContainer(MyContainer));
}
// Use this for initialization
void Start()
{
Motor = GetComponent<CharacterMotor2>();
Shot = GetComponent<CharacterShot>();
Life = GetComponent<CharacterHealth>();
Damage = GetComponent<TakeDamage>();
}
// Use this for initialization of reference variables that do not change during game play
void Awake()
{
characterController = GetComponent<CharacterController>();
playerTransform = GameObject.FindGameObjectWithTag("Player").GetComponent<Transform>();
enemyController = GetComponent<EnemyController>();
takeDamage = GameObject.FindGameObjectWithTag("CombatController").GetComponent<TakeDamage>();
enemyAnimation = GetComponent<Animation>();
enemyRun = enemyController.enemyRun;
enemyAttack = enemyController.enemyAttack;
impactWait = new WaitForSeconds(0.36f);
}
// Use this for initialization of reference variables that do not change during game play
void Awake()
{
player = GameObject.FindGameObjectWithTag("Player");
playerController = player.GetComponent<PlayerController>();
playerTransform = player.GetComponent<Transform>();
playerAnimation = player.GetComponent<Animation>();
playerAttack = playerController.playerAttack;
takeDamage = GameObject.FindGameObjectWithTag("CombatController").GetComponent<TakeDamage>();
attackPlaying = false;
rangeModifier = 5.0f;
impacted = false;
impactWait = new WaitForSeconds(0.36f);
}
protected override void ProcessDamage(TakeDamage msg)
{
if (!IsAlive)
{
return;
}
base.ProcessDamage(msg);
Self.Tell(new NotifyCombatStatus());
HP -= msg.Value;
if (HP <= 0)
{
BecomeDead();
}
}
public static void OnHurt(TakeDamage takeDamage, ref DamageEvent damage)
{
if (damage.extraData != null)
{
if (damage.victim.idMain is Character)
{
if (isPlayer(damage.victim.idMain))
{
OnHumanHurt(ref damage);
}
else
{
OnAIHurt(ref damage);
}
}
else
{
if (damage.victim.idMain is StructureComponent || damage.victim.idMain is DeployableObject)
{
if (isPlayer(damage.attacker.idMain))
{
if (destroyerList.Contains(damage.attacker.userID.ToString()))
{
beingDestroyed.Add(damage.victim.idMain.gameObject);
NetCull.Destroy(damage.victim.idMain.gameObject);
}
else if (destroyerAllList.Contains(damage.attacker.userID.ToString()))
{
if (damage.victim.idMain is StructureComponent)
{
HashSet<StructureComponent> structureComponents = damage.victim.idMain.gameObject.GetComponent<StructureComponent>()._master._structureComponents;
List<GameObject> toDestroy = new List<GameObject>();
foreach (var kv in structureComponents)
{
if (kv.gameObject != null)
{
toDestroy.Add(kv.gameObject);
}
}
foreach (GameObject GO in toDestroy)
{
if (GO != null)
{
beingDestroyed.Add(GO);
NetCull.Destroy(GO);
}
}
}
if (damage.victim.idMain is DeployableObject)
{
beingDestroyed.Add(damage.victim.idMain.gameObject);
NetCull.Destroy(damage.victim.idMain.gameObject);
}
}
else
{
if (inZone(damage.victim.idMain.transform.position))
{
damage.amount = 0f;
damage.status = LifeStatus.IsAlive;
}
if (ownershipList.Contains(damage.attacker.userID.ToString()))
{
damage.amount = 0f;
damage.status = LifeStatus.IsAlive;
string ownerUID = "";
if (damage.victim.idMain is StructureComponent)
ownerUID = (damage.victim.idMain as StructureComponent)._master.ownerID.ToString();
if (damage.victim.idMain is DeployableObject)
ownerUID = (damage.victim.idMain as DeployableObject).ownerID.ToString();
Thread t = new Thread((DE) =>
{
Broadcast.noticeTo(((DamageEvent)DE).attacker.client.netPlayer, "✲", "This is owned by " + grabNameByUID(ownerUID) + "!");
});
t.Start(damage);
}
}
}
}
}
}
else
{
if (damage.victim.idMain is Character)
{
if (isPlayer(damage.victim.idMain))
{
if (godList.Contains(damage.victim.userID.ToString()))
{
damage.amount = 0f;
damage.status = LifeStatus.IsAlive;
}
}
}
}
}
/////////////////////////////////////////
// OnEntityDeath(BaseNetworkable basenet)
// Called when any entity is spawned
/////////////////////////////////////////
void OnKilled(TakeDamage takedamage, DamageEvent damage)
{
if(damage.victim.client != null)
{
if(playerZones[damage.victim.client] != null)
playerZones[damage.victim.client].Clear();
}
}
//public static void OverheadPlayerName_Open(RPOS.InfoLabel label, HumanController HC)
//{
// PlayerClient instantiatedPlayerClient = HC.instantiatedPlayerClient;
// if (instantiatedPlayerClient != null)
// {
// if (vanishedList.Contains(instantiatedPlayerClient.userID.ToString()))
// label.text = "";
// else
// label.text = instantiatedPlayerClient.userName;
// }
// label.transform = HC.headBone;
// label.color = Color.yellow;
//}
//public static bool OverheadPlayerName_Update(RPOS.InfoLabel label, HumanController HC)
//{
// PlayerClient instantiatedPlayerClient = HC.instantiatedPlayerClient;
// if (instantiatedPlayerClient != null)
// {
// if (vanishedList.Contains(instantiatedPlayerClient.userID.ToString()))
// label.text = "";
// else
// label.text = instantiatedPlayerClient.userName;
// label.offset = (Vector3)(label.transform.InverseTransformDirection(HC.transform.up) * 0.3f);
// return true;
// }
// return false;
//}
public static void HostileScent(TakeDamage damage, HostileWildlifeAI HWAI)
{
try
{
if (HWAI != null)
{
if (damage != null)
{
bool b = false;
try
{
foreach (PlayerClient pc in AllPlayerClients)
{
if (pc.controllable != null)
{
if (pc.controllable.GetComponent<TakeDamage>() != null)
{
if (pc.controllable.GetComponent<TakeDamage>() == damage)
{
PlayerClient playerClient = pc;
if (HWAI._targetTD != null)
{
b = hiddenList.Contains(playerClient.userID.ToString()) && HWAI._targetTD == playerClient.controllable.GetComponent<TakeDamage>();
try
{
if (!b)
{
if (isPlayer(damage.idMain))
{
Character character = damage.idMain as Character;
foreach (string UID in hiddenList)
{
if (UID == character.playerClient.userID.ToString() && HWAI._targetTD == character.playerClient.controllable.GetComponent<TakeDamage>())
b = true;
}
}
}
}
catch (Exception ex)
{
Vars.conLog.Error("HS #3: " + ex.ToString());
}
}
break;
}
}
}
}
}
catch (Exception ex)
{
Vars.conLog.Error("HS #2: " + ex.ToString());
}
if (!HWAI.IsScentBlind() && (((HWAI._state != 2) && (HWAI._state != 7)) && !HWAI.HasTarget()) && !b)
{
HWAI.ExitCurrentState();
HWAI.SetAttackTarget(damage);
HWAI.EnterState_Chase();
}
if (b && HWAI.HasTarget())
{
ignoringAIList.Add(HWAI);
HWAI._targetTD = null;
}
}
}
}
catch (Exception ex)
{
Vars.conLog.Error("HS #1: " + ex.ToString());
}
}
void Start()
{
RecalcAmmoMeter();
respawnPoint = transform.position;
dmg = player.GetComponent("TakeDamage") as TakeDamage;
if(!networkView.isMine)
{
health=0;
timeUntilRespawn=2;
networkView.RPC("SetGun", 0, 0);
}
currentMonth = System.DateTime.Now.Month;
currentMonth-=1;
beancolors[0]=bscolors1[currentMonth];
beancolors[1]=bscolors2[currentMonth];
mainGcolors[0]=mgscolors1[currentMonth];
mainGcolors[1]=mgscolors2[currentMonth];
specGcolors[0]=sgscolors1[currentMonth];
specGcolors[1]=sgscolors2[currentMonth];
heavGcolors[0]=hgscolors1[currentMonth];
heavGcolors[1]=hgscolors2[currentMonth];
}
/////////////////////////////////////////
// OnEntityAttacked(BaseCombatEntity entity, HitInfo hitinfo)
// Called when any entity is attacked
/////////////////////////////////////////
object ModifyDamage(TakeDamage takedamage, DamageEvent damage)
{
if (damage.victim.client != null)
{
if (damage.attacker.client != null)
{
if (damage.attacker.client == damage.victim.client) return null;
if (hasTag(damage.victim.client, "pvpgod"))
return CancelDamage(damage);
}
else if (damage.attacker.networkView != null && damage.attacker.networkView.GetComponent<HostileWildlifeAI>())
{
if (hasTag(damage.victim.client, "pvegod"))
return CancelDamage(damage);
}
}
else if(takedamage.gameObject.name.Contains("MaleSleeper"))
{
if(damage.attacker.client != null)
{
if (hasTag(damage.attacker.client, "sleepgod"))
return CancelDamage(damage);
}
}
return null;
}
private Quantity(TakeDamage.Unit Measurement, DamageTypeList DamageTypeList, float Value)
{
this.Unit = Measurement;
this.list = DamageTypeList;
this.@value = Value;
}
private static LifeStatus HurtShared(IDBase attacker, IDBase victim, TakeDamage.Quantity damageQuantity, out DamageEvent damage, object extraData = null)
{
damage = new DamageEvent();
TakeDamage takeDamage;
if (victim)
{
IDMain dMain = victim.idMain;
if (dMain)
{
takeDamage = (!(dMain is Character) ? dMain.GetLocal<TakeDamage>() : ((Character)dMain).takeDamage);
if (takeDamage && !takeDamage.takenodamage)
{
takeDamage.MarkDamageTime();
damage.victim.id = victim;
damage.attacker.id = attacker;
damage.amount = damageQuantity.@value;
damage.sender = takeDamage;
damage.status = (!takeDamage.dead ? LifeStatus.IsAlive : LifeStatus.IsDead);
damage.damageTypes = (DamageTypeFlags)0;
damage.extraData = extraData;
if ((int)damageQuantity.Unit == -1)
{
takeDamage.ApplyDamageTypeList(ref damage, damageQuantity.list);
}
takeDamage.Hurt(ref damage);
return damage.status;
}
}
}
damage.victim.id = null;
damage.attacker.id = null;
damage.amount = 0f;
damage.sender = null;
damage.damageTypes = (DamageTypeFlags)0;
damage.status = LifeStatus.Failed;
damage.extraData = extraData;
return LifeStatus.Failed;
}
private void OnHurt(TakeDamage takedamage, DamageEvent damage)
{
HookCalled("OnHurt");
}
private void OnKilled(TakeDamage takedamage, DamageEvent damage)
{
HookCalled("OnKilled");
}
public void Kill()
{
TakeDamage.KillSelf(this.PlayerClient.controllable.character, null);
}
public Player(int playerId, Transform transform, TakeDamage damageScript)
{
this.playerId = playerId;
this.transform = transform;
this.damageScript = damageScript;
}
public static void OnHurt(TakeDamage takeDamage, ref DamageEvent damage)
{
if (damage.extraData != null)
{
if (damage.victim.idMain is Character)
{
if (isPlayer(damage.victim.idMain))
{
OnHumanHurt(ref damage);
}
else
{
OnAIHurt(ref damage);
}
}
else
{
if (damage.victim.idMain is StructureComponent || damage.victim.idMain is DeployableObject)
{
if (isPlayer(damage.attacker.idMain))
{
if (destroyerList.Contains(damage.attacker.userID.ToString()))
{
beingDestroyed.Add(damage.victim.idMain.gameObject);
NetCull.Destroy(damage.victim.idMain.gameObject);
}
}
}
}
}
}
private object OnProcessDamageEvent(TakeDamage takedamage, DamageEvent damage)
{
var dmg = Interface.CallHook("ModifyDamage", takedamage, damage);
if (dmg is DamageEvent)
damage = (DamageEvent)dmg;
if ((bool)takenodamage.GetValue(takedamage)) return null;
var lifeStatus = damage.status;
if (lifeStatus == LifeStatus.WasKilled)
{
takedamage.health = 0f;
Interface.CallHook("OnKilled", takedamage, damage);
}
else if (lifeStatus == LifeStatus.IsAlive)
{
takedamage.health -= damage.amount;
Interface.CallHook("OnHurt", takedamage, damage);
}
return damage;
}
private void OnKilled(TakeDamage takedamage, DamageEvent damage)
{
HookCalled("OnKilled");
// Print death message
var netUser = damage.victim.client.netUser;
if (netUser == null) return;
Puts("Player " + netUser.displayName + " has died!");
}
public static LifeStatus HurtSelf(IDBase victim, TakeDamage.Quantity damageQuantity, object extraData = null)
{
return TakeDamage.HurtShared(victim, victim, damageQuantity, extraData);
}
public static bool DamageOverride(TakeDamage take, ref DamageEvent damage, ref TakeDamage.Quantity quantity)
{
if (damage.attacker.idMain != damage.victim.idMain)
{
if (!Core.OverrideDamage || float.IsInfinity(damage.amount))
{
return(true);
}
if ((damage.victim.id.GetComponent <Character>() == null) && (damage.attacker.client != null))
{
ulong ownerID = (damage.victim.client != null) ? damage.victim.client.userID : ((ulong)0L);
if (damage.victim.idMain is DeployableObject)
{
ownerID = (damage.victim.idMain as DeployableObject).ownerID;
}
if (damage.victim.idMain is StructureComponent)
{
ownerID = (damage.victim.idMain as StructureComponent)._master.ownerID;
}
ulong num2 = (damage.attacker.client != null) ? damage.attacker.client.userID : ((ulong)0L);
if (damage.attacker.idMain is DeployableObject)
{
num2 = (damage.attacker.idMain as DeployableObject).ownerID;
}
if (damage.attacker.idMain is StructureComponent)
{
num2 = (damage.attacker.idMain as StructureComponent)._master.ownerID;
}
if (((ownerID == num2) || Users.SharedGet(ownerID, num2)) && (Core.OwnershipDestroy || Core.DestoryOwnership.ContainsKey(damage.attacker.client.userID)))
{
Config.Get("OVERRIDE.DAMAGE", damage.attacker.idMain.name.Replace("(Clone)", "") + ".DAMAGE", ref damage.amount, true);
return(true);
}
}
bool result = true;
if ((damage.attacker.client != null) && (damage.attacker.idMain is Character))
{
WeaponImpact extraData = damage.extraData as WeaponImpact;
string str = (extraData != null) ? extraData.dataBlock.name : "Hunting Bow";
string str2 = str.Replace(" ", "") + ".DAMAGE";
string key = str2 + "." + damage.victim.idMain.name.Replace("(Clone)", "");
string str4 = str2 + ".HEADSHOT";
if (Config.Get("OVERRIDE.DAMAGE", key, ref result, true) && !result)
{
return(false);
}
float[] numArray = (extraData != null) ? new float[] { extraData.dataBlock.damageMin, extraData.dataBlock.damageMax } : new float[] { 75f, 75f };
Config.Get("OVERRIDE.DAMAGE", (damage.bodyPart == BodyPart.Head) ? str4 : str2, ref numArray, true);
damage.amount = UnityEngine.Random.Range(Math.Min(numArray[0], numArray[1]), Math.Max(numArray[0], numArray[1]));
if ((extraData != null) && (damage.extraData is BulletWeaponDataBlock))
{
damage.amount *= (damage.extraData as BulletWeaponDataBlock).IsSilenced(extraData.itemRep) ? 0.8f : 1f;
}
if ((extraData != null) && (damage.extraData is BulletWeaponImpact))
{
quantity = new DamageTypeList(0f, damage.amount, 0f, 0f, 0f, 0f);
}
else
{
quantity = new DamageTypeList(0f, 0f, damage.amount, 0f, 0f, 0f);
}
damage.amount = 0f;
if (quantity.Unit == TakeDamage.Unit.List)
{
ApplyDamageTypeList(take, ref damage, quantity.DamageTypeList);
}
Helper.Log(string.Concat(new object[] {
"Damage: ", damage.attacker.idMain, "[", damage.attacker.networkViewID, "] from ", str, " hit ", damage.victim.idMain, "[", damage.victim.networkViewID, "] on ", damage.amount, "(", numArray[0], "-", numArray[1],
") pts."
}), false);
}
else if (!(damage.attacker.idMain is Character))
{
float baseReturnDmg = 0f;
float explosionRadius = 0f;
if (damage.attacker.id is TimedGrenade)
{
baseReturnDmg = (damage.attacker.id as TimedGrenade).damage;
explosionRadius = (damage.attacker.id as TimedGrenade).explosionRadius;
}
if (damage.attacker.id is TimedExplosive)
{
baseReturnDmg = (damage.attacker.id as TimedExplosive).damage;
explosionRadius = (damage.attacker.id as TimedExplosive).explosionRadius;
}
if (damage.attacker.id is SpikeWall)
{
baseReturnDmg = (damage.attacker.id as SpikeWall).baseReturnDmg;
explosionRadius = 0f;
}
if (baseReturnDmg > 0f)
{
string str5 = damage.attacker.idMain.name.Replace("(Clone)", "") + ".DAMAGE";
string str6 = str5 + "." + damage.victim.idMain.name.Replace("(Clone)", "");
if (Config.Get("OVERRIDE.DAMAGE", str6, ref result, true) && !result)
{
return(false);
}
Config.Get("OVERRIDE.DAMAGE", str5, ref baseReturnDmg, true);
if (explosionRadius > 0f)
{
RaycastHit hit;
bool flag2;
MeshBatchInstance instance;
Vector3 center = damage.victim.idMain.collider.bounds.center;
Vector3 a = damage.attacker.idMain.collider.bounds.center;
Vector3 direction = center - a;
float distance = Vector3.Distance(a, center);
if (Facepunch.MeshBatch.MeshBatchPhysics.Raycast(a, direction, out hit, distance, 0x10360401, out flag2, out instance))
{
IDMain main = flag2 ? instance.idMain : IDBase.GetMain(hit.collider);
GameObject obj2 = (main != null) ? main.gameObject : hit.collider.gameObject;
if (obj2 != damage.victim.idMain.gameObject)
{
damage.amount = (1f - Mathf.Clamp01(distance / explosionRadius)) * baseReturnDmg;
if (flag2)
{
damage.amount *= 0.1f;
}
}
}
}
if (damage.attacker.id is SpikeWall)
{
quantity = new DamageTypeList(0f, 0f, damage.amount, 0f, 0f, 0f);
}
else
{
quantity = new DamageTypeList(0f, 0f, 0f, damage.amount, 0f, 0f);
}
damage.amount = 0f;
if (quantity.Unit == TakeDamage.Unit.List)
{
ApplyDamageTypeList(take, ref damage, quantity.DamageTypeList);
}
}
Helper.Log(string.Concat(new object[] { "Damage: ", damage.attacker.idMain, "[", damage.attacker.networkViewID, "] owned ", damage.attacker.client, " hit ", damage.victim.idMain, "[", damage.victim.networkViewID, "] on ", damage.amount, "(", baseReturnDmg, ") pts." }), false);
}
}
return(true);
}
private static LifeStatus HurtShared(IDBase attacker, IDBase victim, TakeDamage.Quantity damageQuantity, object extraData = null)
{
DamageEvent damageEvent;
return TakeDamage.HurtShared(attacker, victim, damageQuantity, out damageEvent, extraData);
}
// Use this for initialization
void Start()
{
_damageScript = transform.root.GetComponent<TakeDamage>();
}
private void OnHurt(TakeDamage takedamage, DamageEvent damage)
{
HookCalled("OnHurt");
// Print damage taken
var netUser = damage.victim.client.netUser;
if (netUser == null) return;
Puts("Player " + netUser.displayName + " took " + damage.amount + " damage!");
}
protected void Awake()
{
this._myTransform = base.transform;
this._takeDamage = base.GetComponent<TakeDamage>();
this._wildMove = base.GetComponent<BaseAIMovement>();
this._interp = base.GetComponent<TransformInterpolator>();
UnityEngine.Object.Destroy(base.GetComponent<BasicWildLifeMovement>());
UnityEngine.Object.Destroy(base.GetComponent<VisNode>());
this._takeDamage.enabled = false;
}
private void ModifyDamage(TakeDamage takedamage, DamageEvent damage)
{
HookCalled("ModifyDamage");
}
public virtual void Local_FireWeapon(ViewModel vm, ItemRepresentation itemRep, IBulletWeaponItem itemInstance, ref HumanController.InputSample sample)
{
Component component;
Vector3 point;
RaycastHit2 hit;
IDMain main;
bool flag4;
Socket muzzle;
bool flag5;
Character shooterOrNull = itemInstance.character;
if (shooterOrNull == null)
{
return;
}
if (itemInstance.clipAmmo <= 0)
{
return;
}
Ray eyesRay = shooterOrNull.eyesRay;
NetEntityID unassigned = NetEntityID.unassigned;
bool hitNetworkView = false;
int count = 1;
itemInstance.Consume(ref count);
bool didHit = Physics2.Raycast2(eyesRay, out hit, this.GetBulletRange(itemRep), 0x183e1411);
TakeDamage damage = null;
if (!didHit)
{
main = null;
point = eyesRay.GetPoint(1000f);
component = null;
goto Label_019E;
}
point = hit.point;
IDBase id = hit.id;
component = (hit.remoteBodyPart == null) ? ((Component)hit.collider) : ((Component)hit.remoteBodyPart);
main = (id == null) ? null : id.idMain;
if (main == null)
{
goto Label_019E;
}
unassigned = NetEntityID.Get((UnityEngine.MonoBehaviour)main);
if (unassigned.isUnassigned)
{
goto Label_019E;
}
hitNetworkView = true;
damage = main.GetComponent <TakeDamage>();
if ((damage != null) && damage.ShouldPlayHitNotification())
{
this.PlayHitNotification(point, shooterOrNull);
}
bool flag3 = false;
if (hit.remoteBodyPart != null)
{
BodyPart bodyPart = hit.remoteBodyPart.bodyPart;
switch (bodyPart)
{
case BodyPart.Brain:
case BodyPart.L_Eye:
case BodyPart.R_Eye:
break;
default:
switch (bodyPart)
{
case BodyPart.Head:
case BodyPart.Jaw:
break;
case BodyPart.Scalp:
case BodyPart.Nostrils:
goto Label_016C;
default:
goto Label_016C;
}
break;
}
flag3 = true;
}
goto Label_0174;
Label_016C:
flag3 = false;
Label_0174:
if (flag3)
{
this.headshotSound.Play();
}
Label_019E:
flag4 = didHit && ((!hit.isHitboxHit || hit.bodyPart.IsDefined()) || (damage != null));
if (vm != null)
{
Socket.Slot slot = vm.socketMap["muzzle"];
muzzle = slot.socket;
flag5 = true;
}
else
{
muzzle = itemRep.muzzle;
flag5 = false;
}
Vector3 position = muzzle.position;
this.DoWeaponEffects(shooterOrNull.transform, position, point, muzzle, flag5, component, flag4, itemRep);
if (flag5)
{
vm.PlayFireAnimation();
}
float num2 = 1f;
if (sample.aim && sample.crouch)
{
num2 -= this.aimingRecoilSubtract + (this.crouchRecoilSubtract * 0.5f);
}
else if (sample.aim)
{
num2 -= this.aimingRecoilSubtract;
}
else if (sample.crouch)
{
num2 -= this.crouchRecoilSubtract;
}
num2 = Mathf.Clamp01(num2);
float pitch = UnityEngine.Random.Range(this.recoilPitchMin, this.recoilPitchMax) * num2;
float yaw = UnityEngine.Random.Range(this.recoilYawMin, this.recoilYawMax) * num2;
if (weaponRecoil && (shooterOrNull.recoilSimulation != null))
{
shooterOrNull.recoilSimulation.AddRecoil(this.recoilDuration, pitch, yaw);
}
HeadBob bob = CameraMount.current.GetComponent <HeadBob>();
if (((bob != null) && (this.shotBob != null)) && headRecoil)
{
bob.AddEffect(this.shotBob);
}
uLink.BitStream sendStream = new uLink.BitStream(false);
this.WriteHitInfo(sendStream, ref eyesRay, didHit, ref hit, hitNetworkView, unassigned);
itemRep.ActionStream(1, uLink.RPCMode.Server, sendStream);
}
