private void Start()
{
localController = null;
brickSeq = -1;
shooter = -1;
InitializeAnimation();
audioSource = GetComponent <AudioSource>();
BrickProperty component = base.transform.parent.GetComponent <BrickProperty>();
if (null == component)
{
Debug.LogError("ERROR, Fail to get brick sequence number for cannon controller");
}
else
{
brickSeq = component.Seq;
}
if (null != axle)
{
SaveAxleAngle();
}
muzzleFxInstances = new GameObject[muzzles.Length];
for (int i = 0; i < muzzles.Length; i++)
{
muzzleFxInstances[i] = null;
}
}
protected void DrawCrossHair()
{
if (Screen.lockCursor)
{
GUI.depth = 35;
Color color = GUI.color;
GUI.color = Config.instance.crosshairColor;
if (null != vCrossHair)
{
Vector2 vector = new Vector2((float)((Screen.width - 8) / 2), (float)(Screen.height / 2 - 8));
TextureUtil.DrawTexture(new Rect(vector.x, vector.y, 8f, 8f), vCrossHair, ScaleMode.StretchToFill, alphaBlend: true);
vector = new Vector2((float)((Screen.width - 8) / 2), (float)(Screen.height / 2));
TextureUtil.DrawTexture(new Rect(vector.x, vector.y, 8f, 8f), vCrossHair, ScaleMode.StretchToFill, alphaBlend: true);
}
if (null != hCrossHair)
{
Vector2 vector = new Vector2((float)(Screen.width / 2 - 8), (float)((Screen.height - 8) / 2));
TextureUtil.DrawTexture(new Rect(vector.x, vector.y, 8f, 8f), hCrossHair, ScaleMode.StretchToFill, alphaBlend: true);
vector = new Vector2((float)(Screen.width / 2), (float)((Screen.height - 8) / 2));
TextureUtil.DrawTexture(new Rect(vector.x, vector.y, 8f, 8f), hCrossHair, ScaleMode.StretchToFill, alphaBlend: true);
}
GUI.color = color;
string text = string.Empty;
if (null != localCtrl)
{
float horzAngle = localCtrl.GetHorzAngle();
if ((292.5 <= (double)horzAngle && horzAngle <= 360f) || (0f <= horzAngle && horzAngle <= 67.5f))
{
text += "N";
}
else if (112.5f <= horzAngle && horzAngle <= 247.5f)
{
text += "S";
}
if (22.5f <= horzAngle && horzAngle <= 157.5f)
{
text += "E";
}
else if (202.5f <= horzAngle && horzAngle <= 337.5f)
{
text += "W";
}
}
if (distance != float.PositiveInfinity && hitBrick.transform != null)
{
BrickProperty hitBrickProperty = BrickManager.Instance.GetHitBrickProperty(hitBrick.transform.gameObject, hitBrick.normal, hitBrick.point);
if (null != hitBrickProperty)
{
text += ": ";
text = text + distance.ToString("0.#") + "m";
}
}
LabelUtil.TextOut(new Vector2((float)(Screen.width / 2), (float)(Screen.height / 2 + 16)), text, "Label", Color.white, Color.black, TextAnchor.MiddleCenter);
}
}
private void OnLoadComplete()
{
TrainManager.Instance.Load();
BrickManManager.Instance.InitFlagVars();
SpawnerDesc spawner = BrickManager.Instance.GetSpawner(MyInfoManager.Instance.GetTeamSpawnerType(), MyInfoManager.Instance.Ticket);
if (spawner != null)
{
localController.Spawn(spawner.position, Rot.ToQuaternion(spawner.rotation));
}
else
{
localController.Spawn(BrickManager.Instance.GetRandomSpawnPos(), Rot.ToQuaternion((byte)UnityEngine.Random.Range(0, 4)));
}
if (!MyInfoManager.Instance.GetCommonMask(MyInfoManager.COMMON_OPT.DONOT_FLAG_GUIDE))
{
FLAGGuideDialog fLAGGuideDialog = (FLAGGuideDialog)DialogManager.Instance.GetDialogAlways(DialogManager.DIALOG_INDEX.FLAG_GUIDE);
if (fLAGGuideDialog != null && !fLAGGuideDialog.DontShowThisMessageAgain)
{
((FLAGGuideDialog)DialogManager.Instance.Popup(DialogManager.DIALOG_INDEX.FLAG_GUIDE, exclusive: false))?.InitDialog();
}
}
SpawnerDesc spawner2 = BrickManager.Instance.userMap.GetSpawner(Brick.SPAWNER_TYPE.FLAG_SPAWNER, 0);
FlagObj.transform.position = new Vector3(spawner2.position.x, spawner2.position.y - 0.3f, spawner2.position.z);
BrickManManager.Instance.vFlag = FlagObj.transform.position;
rbPlanes[2].transform.position = spawner2.position;
spawner2 = BrickManager.Instance.userMap.GetSpawner(Brick.SPAWNER_TYPE.RED_FLAG_SPAWNER, 0);
rbPlanes[0].transform.position = spawner2.position;
spawner2 = BrickManager.Instance.userMap.GetSpawner(Brick.SPAWNER_TYPE.BLUE_FLAG_SPAWNER, 0);
rbPlanes[1].transform.position = spawner2.position;
GameObject brickObjectByPos = BrickManager.Instance.GetBrickObjectByPos(FlagObj.transform.position);
if (null != brickObjectByPos)
{
BrickProperty component = brickObjectByPos.GetComponent <BrickProperty>();
if (null == component)
{
Debug.LogError("<FlagObj> get BrickProperty failed..");
return;
}
captureTheFlag = component.Seq;
}
bLoaded = true;
}
public void InitDialog(BrickProperty _prop, Brick _brick, BrickInst _inst)
{
prop = _prop;
brick = _brick;
selected = 0;
scrollPosition = Vector2.zero;
spId = Vector2.zero;
if (_inst.BrickForceScript != null)
{
alias = _inst.BrickForceScript.Alias;
enableOnAwake = _inst.BrickForceScript.EnableOnAwake;
visibleOnAwake = _inst.BrickForceScript.VisibleOnAwake;
cmdList.Clear();
for (int i = 0; i < _inst.BrickForceScript.CmdList.Count; i++)
{
cmdList.Add(_inst.BrickForceScript.CmdList[i]);
}
}
}
public void Show(bool visible)
{
if (!Application.loadedLevelName.Contains("MapEditor"))
{
MeshRenderer[] componentsInChildren = GetComponentsInChildren <MeshRenderer>();
MeshRenderer[] array = componentsInChildren;
foreach (MeshRenderer meshRenderer in array)
{
meshRenderer.enabled = visible;
}
SkinnedMeshRenderer[] componentsInChildren2 = GetComponentsInChildren <SkinnedMeshRenderer>();
SkinnedMeshRenderer[] array2 = componentsInChildren2;
foreach (SkinnedMeshRenderer skinnedMeshRenderer in array2)
{
skinnedMeshRenderer.enabled = visible;
}
ParticleRenderer[] componentsInChildren3 = GetComponentsInChildren <ParticleRenderer>();
ParticleRenderer[] array3 = componentsInChildren3;
foreach (ParticleRenderer particleRenderer in array3)
{
particleRenderer.enabled = visible;
}
BrickProperty component = base.transform.parent.gameObject.GetComponent <BrickProperty>();
if (component.Index == 162)
{
if (visible)
{
component.Visible_t = true;
}
else if (component.Visible_t)
{
BrickManager.Instance.DestroyBrick(component.Seq);
}
}
else if (component.Index == 180 && !visible && GlobalVars.Instance.immediateKillBrickTutor)
{
BrickManager.Instance.DestroyBrick(component.Seq);
GlobalVars.Instance.immediateKillBrickTutor = false;
}
}
}
private static bool IsFaceToMeSameBrick(Vector3 myEye, Vector3 thirdEye, float d, int seq)
{
GameObject gameObject = null;
BrickProperty brickProperty = null;
int layerMask = (1 << LayerMask.NameToLayer("Chunk")) | (1 << LayerMask.NameToLayer("Brick"));
Ray ray = default(Ray);
ray.origin = thirdEye;
ray.direction = Vector3.Normalize(myEye - ray.origin);
if (Physics.Raycast(ray, out RaycastHit hitInfo, 1000f, layerMask))
{
float num = Vector3.Distance(hitInfo.point, thirdEye);
if (d > num)
{
GameObject gameObject2 = hitInfo.transform.gameObject;
if (gameObject2.layer == LayerMask.NameToLayer("Brick"))
{
BrickProperty[] allComponents = Recursively.GetAllComponents <BrickProperty>(gameObject2.transform, includeInactive: false);
if (allComponents.Length > 0)
{
brickProperty = allComponents[0];
}
}
else
{
gameObject = BrickManager.Instance.GetBrickObjectByPos(Brick.ToBrickCoord(hitInfo.normal, hitInfo.point));
if (null != gameObject)
{
brickProperty = gameObject.GetComponent <BrickProperty>();
}
}
if (null != brickProperty && brickProperty.Seq == seq)
{
return(true);
}
}
}
return(false);
}
private void Start()
{
script = null;
BrickProperty component = base.transform.parent.gameObject.GetComponent <BrickProperty>();
if (null == component)
{
Debug.LogError("Fail to find BrickProperty");
}
else
{
BrickInst brickInst = BrickManager.Instance.GetBrickInst(component.Seq);
if (brickInst == null)
{
Debug.LogError("Fail to find BrickInst ");
}
else
{
script = brickInst.BrickForceScript;
}
base.enabled = script.EnableOnAwake;
Show(script.VisibleOnAwake);
}
}
public static SEND_PACKET_LEVEL check3rdPersonSendOrNoSend(GameObject player, Vector3 shootpos, Vector3 hitpoint, Vector3 shootdir, Vector3 hitnormal, int brickSeq, float range, bool possibleCan)
{
if (null == player)
{
return(SEND_PACKET_LEVEL.NONE);
}
int layerMask = (1 << LayerMask.NameToLayer("Chunk")) | (1 << LayerMask.NameToLayer("Brick"));
GameObject gameObject = null;
BrickProperty brickProperty = null;
Ray ray = default(Ray);
bool flag = true;
bool flag2 = true;
float num = 0f;
Plane plane = default(Plane);
shootpos.y += 1.2f;
TPController component = player.GetComponent <TPController>();
if ((bool)component)
{
float num2 = Vector3.Distance(shootpos, component.transform.position);
bool flag3 = false;
if (num2 < inputMinDistance)
{
flag3 = true;
}
bool flag4 = false;
if (num2 > inputMaxDistance)
{
flag4 = true;
}
Vector3 position = component.transform.position;
Vector3 position2 = component.transform.position;
position2.y += 10f;
Vector3 c = component.transform.position + component.lookAt() * 30f;
plane.Set3Points(position, position2, c);
flag = true;
Vector3 rhs = shootpos - component.transform.position;
rhs.Normalize();
num = Vector3.Dot(component.lookAt(), rhs);
if (num < 0.2f)
{
flag = false;
}
flag2 = true;
rhs = hitpoint - component.transform.position;
rhs.Normalize();
num = Vector3.Dot(component.lookAt(), rhs);
if (num <= 0.2f)
{
flag2 = false;
}
if (flag3)
{
return(SEND_PACKET_LEVEL.ALL);
}
if (flag4)
{
return(SEND_PACKET_LEVEL.NONE);
}
Vector3 position3 = component.transform.position;
position3.y += 1.2f;
ray.origin = position3;
ray.direction = Vector3.Normalize(hitpoint - ray.origin);
bool flag5 = false;
if (Physics.Raycast(ray, out RaycastHit hitInfo, range, layerMask))
{
GameObject gameObject2 = hitInfo.transform.gameObject;
if (gameObject2.layer == LayerMask.NameToLayer("Brick"))
{
BrickProperty[] allComponents = Recursively.GetAllComponents <BrickProperty>(gameObject2.transform, includeInactive: false);
if (allComponents.Length > 0)
{
brickProperty = allComponents[0];
}
}
else
{
gameObject = BrickManager.Instance.GetBrickObjectByPos(Brick.ToBrickCoord(hitInfo.normal, hitInfo.point));
if (null != gameObject)
{
brickProperty = gameObject.GetComponent <BrickProperty>();
}
}
if (null != brickProperty && brickSeq != brickProperty.Seq)
{
flag5 = true;
}
}
ray.direction = Vector3.Normalize(shootpos - ray.origin);
bool flag6 = false;
if (Physics.Raycast(ray, out hitInfo, num2 + 1f, layerMask))
{
float num3 = Vector3.Distance(hitInfo.point, component.transform.position);
if (num2 > num3)
{
flag6 = true;
}
}
if (!flag && !flag2)
{
return(SEND_PACKET_LEVEL.NONE);
}
if (!flag5 && !flag6)
{
return(SEND_PACKET_LEVEL.ALL);
}
if (flag5 || !flag2)
{
if (!flag6)
{
return(SEND_PACKET_LEVEL.EXCEPT_EFFECT);
}
if (num2 < 20f)
{
return(SEND_PACKET_LEVEL.ONLY_SOUND);
}
return(SEND_PACKET_LEVEL.NONE);
}
if (!possibleCan && flag5 && flag6)
{
float distanceToPoint = plane.GetDistanceToPoint(shootpos);
float distanceToPoint2 = plane.GetDistanceToPoint(hitpoint);
if (distanceToPoint < distanceToPoint2)
{
return(SEND_PACKET_LEVEL.NONE);
}
if (distanceToPoint * distanceToPoint2 < 0f)
{
Vector3 intersection = Vector3.zero;
if (LinePlaneIntersection(out intersection, shootpos, shootdir, plane.normal, position3))
{
ray.direction = component.lookAt();
if (Physics.Raycast(ray, out hitInfo, 30f, layerMask))
{
return(SEND_PACKET_LEVEL.EXCEPT_EFFECT);
}
}
}
}
return(SEND_PACKET_LEVEL.ALL);
}
return(SEND_PACKET_LEVEL.ALL);
}
public static SEND_PACKET_LEVEL checkSendDir(GameObject player, Vector3 myPos, Bounds bounds)
{
if (null == player)
{
return(SEND_PACKET_LEVEL.NONE);
}
GameObject gameObject = null;
BrickProperty brickProperty = null;
TPController component = player.GetComponent <TPController>();
if ((bool)component)
{
Vector3 vector = new Vector3(myPos.x, myPos.y + 1.2f, myPos.z);
Vector3 position = component.transform.position;
float x = position.x;
Vector3 position2 = component.transform.position;
float y = position2.y + 1.2f;
Vector3 position3 = component.transform.position;
Vector3 vector2 = new Vector3(x, y, position3.z);
float num = Vector3.Distance(myPos, component.transform.position);
Camera[] componentsInChildren = player.GetComponentsInChildren <Camera>();
if (componentsInChildren.Length > 0)
{
camera = componentsInChildren[0];
camera.fieldOfView = 75f;
camera.nearClipPlane = 0.3f;
camera.farClipPlane = 1000f;
}
camera.transform.position = vector2;
camera.transform.rotation = component.transform.rotation;
Plane[] planes = GeometryUtility.CalculateFrustumPlanes(camera);
if (GeometryUtility.TestPlanesAABB(planes, bounds))
{
int layerMask = (1 << LayerMask.NameToLayer("Chunk")) | (1 << LayerMask.NameToLayer("Brick"));
Ray ray = default(Ray);
ray.origin = vector2;
ray.direction = Vector3.Normalize(vector - ray.origin);
if (Physics.Raycast(ray, out RaycastHit hitInfo, 1000f, layerMask))
{
float num2 = Vector3.Distance(hitInfo.point, vector2);
if (num > num2)
{
GameObject gameObject2 = hitInfo.transform.gameObject;
if (gameObject2.layer == LayerMask.NameToLayer("Brick"))
{
BrickProperty[] allComponents = Recursively.GetAllComponents <BrickProperty>(gameObject2.transform, includeInactive: false);
if (allComponents.Length > 0)
{
brickProperty = allComponents[0];
}
}
else
{
gameObject = BrickManager.Instance.GetBrickObjectByPos(Brick.ToBrickCoord(hitInfo.normal, hitInfo.point));
if (null != gameObject)
{
brickProperty = gameObject.GetComponent <BrickProperty>();
}
}
if (null != brickProperty && IsTransparent(brickProperty.Index) && IsFaceToMeSameBrick(vector, vector2, num, brickProperty.Seq))
{
camera.enabled = false;
return(SEND_PACKET_LEVEL.ALL);
}
camera.enabled = false;
return(SEND_PACKET_LEVEL.NONE);
}
}
camera.enabled = false;
return(SEND_PACKET_LEVEL.ALL);
}
camera.enabled = false;
return(SEND_PACKET_LEVEL.NONE);
}
return(SEND_PACKET_LEVEL.ALL);
}
private void CheckSlash()
{
if (isValidRange)
{
int layerMask = (1 << LayerMask.NameToLayer("Chunk")) | (1 << LayerMask.NameToLayer("Brick")) | (1 << LayerMask.NameToLayer("BoxMan")) | (1 << LayerMask.NameToLayer("Mon")) | (1 << LayerMask.NameToLayer("InvincibleArmor")) | (1 << LayerMask.NameToLayer("Bomb")) | (1 << LayerMask.NameToLayer("InstalledBomb"));
Ray ray = cam.ScreenPointToRay(new Vector3((float)(Screen.width / 2), (float)(Screen.height / 2), 0f));
if (Physics.Raycast(ray, out RaycastHit hitInfo, GetComponent <Weapon>().range, layerMask))
{
GameObject gameObject = null;
GameObject gameObject2 = hitInfo.transform.gameObject;
if (gameObject2.layer == LayerMask.NameToLayer("Chunk") || gameObject2.layer == LayerMask.NameToLayer("Brick"))
{
BrickProperty brickProperty = null;
GameObject gameObject3 = null;
if (gameObject2.layer == LayerMask.NameToLayer("Brick"))
{
BrickProperty[] allComponents = Recursively.GetAllComponents <BrickProperty>(gameObject2.transform, includeInactive: false);
if (allComponents.Length > 0)
{
brickProperty = allComponents[0];
}
}
else
{
gameObject = BrickManager.Instance.GetBrickObjectByPos(Brick.ToBrickCoord(hitInfo.normal, hitInfo.point));
if (null != gameObject)
{
brickProperty = gameObject.GetComponent <BrickProperty>();
}
}
if (null != brickProperty)
{
P2PManager.Instance.SendPEER_HIT_BRICK(brickProperty.Seq, brickProperty.Index, hitInfo.point, hitInfo.normal, isBullet: false);
gameObject3 = BrickManager.Instance.GetBulletImpact(brickProperty.Index);
Brick brick = BrickManager.Instance.GetBrick(brickProperty.Index);
if (brick != null && brick.destructible)
{
brickProperty.Hit((int)CalcAtkPow());
if (brickProperty.HitPoint <= 0)
{
if (!Application.loadedLevelName.Contains("Tutor"))
{
CSNetManager.Instance.Sock.SendCS_DESTROY_BRICK_REQ(brickProperty.Seq);
}
gameObject3 = null;
if (brickProperty.Index == 115 || brickProperty.Index == 193)
{
CheckMyself(gameObject.transform.position, GlobalVars.Instance.BoomRadius);
CheckBoxmen(gameObject.transform.position, GlobalVars.Instance.BoomRadius);
CheckMonster(gameObject.transform.position, GlobalVars.Instance.BoomRadius);
CheckDestructibles(gameObject.transform.position, GlobalVars.Instance.BoomRadius);
}
}
else
{
P2PManager.Instance.SendPEER_BRICK_HITPOINT(brickProperty.Seq, brickProperty.HitPoint);
}
}
}
if (null != gameObject3)
{
Object.Instantiate((Object)gameObject3, hitInfo.point, Quaternion.FromToRotation(Vector3.up, hitInfo.normal));
}
}
else if (gameObject2.layer == LayerMask.NameToLayer("BoxMan"))
{
PlayerProperty[] allComponents2 = Recursively.GetAllComponents <PlayerProperty>(gameObject2.transform, includeInactive: false);
TPController[] allComponents3 = Recursively.GetAllComponents <TPController>(gameObject2.transform, includeInactive: false);
if (allComponents2.Length != 1)
{
Debug.LogError("PlayerProperty should be unique for a box man, but it has multiple PlayerProperty components or non ");
}
if (allComponents3.Length != 1)
{
Debug.LogError("TPController should be unique for a box man, but it has multiple TPController components or non ");
}
PlayerProperty playerProperty = null;
TPController tPController = null;
if (allComponents2.Length > 0)
{
playerProperty = allComponents2[0];
}
if (allComponents3.Length > 0)
{
tPController = allComponents3[0];
}
if (playerProperty != null && tPController != null)
{
int num = 0;
HitPart component = gameObject2.GetComponent <HitPart>();
if (component != null)
{
if (component.GetHitImpact() != null)
{
Object.Instantiate((Object)component.GetHitImpact(), hitInfo.point, Quaternion.Euler(0f, 0f, 0f));
}
num = (int)(CalcAtkPow() * component.damageFactor);
if (!playerProperty.IsHostile())
{
num = 0;
}
WeaponFunction component2 = GetComponent <WeaponFunction>();
if (null == component2)
{
Debug.LogError("wpnFunc == nulll");
}
TWeapon tWeapon = (TWeapon)GetComponent <Weapon>().tItem;
if (tWeapon == null)
{
Debug.LogError("wpn == null");
}
Item item = MyInfoManager.Instance.GetItemBySequence(component2.ItemSeq);
if (item == null)
{
item = MyInfoManager.Instance.GetUsingEquipByCode(tWeapon.code);
}
num = GlobalVars.Instance.applyDurabilityDamage(item?.Durability ?? (-1), tWeapon.durabilityMax, num);
P2PManager.Instance.SendPEER_HIT_BRICKMAN(MyInfoManager.Instance.Seq, playerProperty.Desc.Seq, (int)component.part, hitInfo.point, hitInfo.normal, lucky: false, 0, ray.direction);
P2PManager.Instance.SendPEER_PIERCE(MyInfoManager.Instance.Seq, playerProperty.Desc.Seq, num, Rigidity, (int)weaponBy);
}
tPController.GetHit(num, playerProperty.Desc.Seq);
}
}
else if (gameObject2.layer == LayerMask.NameToLayer("Mon"))
{
MonProperty[] allComponents4 = Recursively.GetAllComponents <MonProperty>(gameObject2.transform, includeInactive: false);
MonProperty monProperty = null;
if (allComponents4.Length > 0)
{
monProperty = allComponents4[0];
}
if (monProperty != null)
{
HitPart component3 = gameObject2.GetComponent <HitPart>();
if (component3 != null)
{
if ((MyInfoManager.Instance.Slot < 4 && monProperty.Desc.bRedTeam) || (MyInfoManager.Instance.Slot >= 4 && !monProperty.Desc.bRedTeam))
{
return;
}
if (component3.GetHitImpact() != null)
{
Object.Instantiate((Object)component3.GetHitImpact(), hitInfo.point, Quaternion.Euler(0f, 0f, 0f));
}
if (monProperty.Desc.Xp <= 0)
{
return;
}
int num2 = (int)(CalcAtkPow() * component3.damageFactor);
if (monProperty.Desc.bHalfDamage)
{
num2 /= 2;
}
MonManager.Instance.Hit(monProperty.Desc.Seq, num2, 0f, (int)weaponBy, Vector3.zero, Vector3.zero, -1);
}
}
}
else if (gameObject2.layer == LayerMask.NameToLayer("InvincibleArmor") || gameObject2.layer == LayerMask.NameToLayer("Bomb") || gameObject2.layer == LayerMask.NameToLayer("InstalledBomb"))
{
GameObject impact = VfxOptimizer.Instance.GetImpact(gameObject2.layer);
if (null != impact)
{
Object.Instantiate((Object)impact, hitInfo.point, Quaternion.FromToRotation(Vector3.up, hitInfo.normal));
P2PManager.Instance.SendPEER_HIT_IMPACT(gameObject2.layer, hitInfo.point, hitInfo.normal);
}
}
isValidRange = false;
}
}
}
private void Shoot()
{
Vector2 vector = accuracy.CalcDeflection();
int layerMask = (1 << LayerMask.NameToLayer("Chunk")) | (1 << LayerMask.NameToLayer("Brick")) | (1 << LayerMask.NameToLayer("BoxMan")) | (1 << LayerMask.NameToLayer("Mon")) | (1 << LayerMask.NameToLayer("InvincibleArmor")) | (1 << LayerMask.NameToLayer("Bomb")) | (1 << LayerMask.NameToLayer("InstalledBomb"));
Ray ray = cam.ScreenPointToRay(new Vector3(vector.x, vector.y, 0f));
if (!Application.loadedLevelName.Contains("Tutor"))
{
P2PManager.Instance.SendPEER_CANNON_FIRE(BrickSeq, shooter, ray.origin, ray.direction);
}
if (Physics.Raycast(ray, out RaycastHit hitInfo, Range, layerMask))
{
GameObject gameObject = hitInfo.transform.gameObject;
if (gameObject.layer == LayerMask.NameToLayer("Brick") || gameObject.layer == LayerMask.NameToLayer("Chunk"))
{
GameObject gameObject2 = null;
BrickProperty brickProperty = null;
GameObject original = null;
Texture2D mark = null;
if (gameObject.layer == LayerMask.NameToLayer("Brick"))
{
BrickProperty[] allComponents = Recursively.GetAllComponents <BrickProperty>(gameObject.transform, includeInactive: false);
if (allComponents.Length > 0)
{
brickProperty = allComponents[0];
}
}
else
{
gameObject2 = BrickManager.Instance.GetBrickObjectByPos(Brick.ToBrickCoord(hitInfo.normal, hitInfo.point));
if (null != gameObject2)
{
brickProperty = gameObject2.GetComponent <BrickProperty>();
}
}
if (null != brickProperty)
{
P2PManager.Instance.SendPEER_HIT_BRICK(brickProperty.Seq, brickProperty.Index, hitInfo.point, hitInfo.normal, isBullet: true);
mark = BrickManager.Instance.GetBulletMark(brickProperty.Index);
original = BrickManager.Instance.GetBulletImpact(brickProperty.Index);
Brick brick = BrickManager.Instance.GetBrick(brickProperty.Index);
if (brick != null && brick.destructible)
{
brickProperty.Hit((int)AtkPow);
if (brickProperty.HitPoint <= 0)
{
CSNetManager.Instance.Sock.SendCS_DESTROY_BRICK_REQ(brickProperty.Seq);
mark = null;
original = null;
if (brickProperty.Index == 115 || brickProperty.Index == 193)
{
ExplosionUtil.CheckMyself(gameObject2.transform.position, GlobalVars.Instance.BoomDamage, GlobalVars.Instance.BoomRadius, -3);
ExplosionUtil.CheckBoxmen(gameObject2.transform.position, GlobalVars.Instance.BoomDamage, GlobalVars.Instance.BoomRadius, -3, Rigidity);
ExplosionUtil.CheckMonster(gameObject2.transform.position, GlobalVars.Instance.BoomDamage, GlobalVars.Instance.BoomRadius);
ExplosionUtil.CheckDestructibles(gameObject2.transform.position, GlobalVars.Instance.BoomDamage, GlobalVars.Instance.BoomRadius);
}
}
else
{
P2PManager.Instance.SendPEER_BRICK_HITPOINT(brickProperty.Seq, brickProperty.HitPoint);
}
}
}
if (null != gameObject2 && null != mark)
{
GameObject gameObject3 = Object.Instantiate((Object)BrickManager.Instance.bulletMark, hitInfo.point, Quaternion.FromToRotation(Vector3.forward, -hitInfo.normal)) as GameObject;
BulletMark component = gameObject3.GetComponent <BulletMark>();
component.GenerateDecal(mark, gameObject, gameObject2);
}
if (null != original)
{
Object.Instantiate((Object)original, hitInfo.point, Quaternion.FromToRotation(Vector3.up, hitInfo.normal));
}
}
else if (gameObject.layer == LayerMask.NameToLayer("BoxMan"))
{
PlayerProperty[] allComponents2 = Recursively.GetAllComponents <PlayerProperty>(gameObject.transform, includeInactive: false);
TPController[] allComponents3 = Recursively.GetAllComponents <TPController>(gameObject.transform, includeInactive: false);
if (allComponents2.Length != 1)
{
Debug.LogError("PlayerProperty should be unique for a box man, but it has multiple PlayerProperty components or non ");
}
if (allComponents3.Length != 1)
{
Debug.LogError("TPController should be unique for a box man, but it has multiple TPController components or non ");
}
PlayerProperty playerProperty = null;
TPController tPController = null;
if (allComponents2.Length > 0)
{
playerProperty = allComponents2[0];
}
if (allComponents3.Length > 0)
{
tPController = allComponents3[0];
}
if (playerProperty != null && tPController != null)
{
int num = 0;
HitPart component2 = gameObject.GetComponent <HitPart>();
if (component2 != null)
{
bool flag = false;
if (component2.part == HitPart.TYPE.HEAD)
{
int layerMask2 = 1 << LayerMask.NameToLayer("Brain");
if (Physics.Raycast(ray, out RaycastHit hitInfo2, Range, layerMask2))
{
if (playerProperty.Desc.IsLucky())
{
flag = true;
}
else
{
component2 = hitInfo2.transform.gameObject.GetComponent <HitPart>();
}
}
}
if (component2.GetHitImpact() != null)
{
GameObject original2 = component2.GetHitImpact();
if (flag && null != component2.luckyImpact)
{
original2 = component2.luckyImpact;
}
Object.Instantiate((Object)original2, hitInfo.point, Quaternion.Euler(0f, 0f, 0f));
}
num = (int)(AtkPow * component2.damageFactor);
if (!playerProperty.IsHostile())
{
num = 0;
}
P2PManager.Instance.SendPEER_HIT_BRICKMAN(MyInfoManager.Instance.Seq, playerProperty.Desc.Seq, (int)component2.part, hitInfo.point, hitInfo.normal, flag, 0, ray.direction);
P2PManager.Instance.SendPEER_SHOOT(MyInfoManager.Instance.Seq, playerProperty.Desc.Seq, num, Rigidity, (int)weaponBy, (int)component2.part, flag, rateOfFire);
}
tPController.GetHit(num, playerProperty.Desc.Seq);
}
}
else if (gameObject.layer == LayerMask.NameToLayer("Mon"))
{
MonProperty[] allComponents4 = Recursively.GetAllComponents <MonProperty>(gameObject.transform, includeInactive: false);
MonProperty monProperty = null;
if (allComponents4.Length > 0)
{
monProperty = allComponents4[0];
}
if (monProperty != null)
{
HitPart component3 = gameObject.GetComponent <HitPart>();
if (component3 != null && (MyInfoManager.Instance.Slot >= 4 || !monProperty.Desc.bRedTeam) && (MyInfoManager.Instance.Slot < 4 || monProperty.Desc.bRedTeam))
{
if (component3.GetHitImpact() != null)
{
Object.Instantiate((Object)component3.GetHitImpact(), hitInfo.point, Quaternion.Euler(0f, 0f, 0f));
}
if (monProperty.Desc.Xp > 0)
{
int num2 = (int)(AtkPow * component3.damageFactor);
num2 += DefenseManager.Instance.AddAtkPower;
if (monProperty.Desc.bHalfDamage)
{
num2 /= 2;
}
MonManager.Instance.Hit(monProperty.Desc.Seq, num2, 0f, (int)weaponBy, hitInfo.point, hitInfo.normal, -1);
}
}
}
}
else if (gameObject.layer == LayerMask.NameToLayer("InvincibleArmor") || gameObject.layer == LayerMask.NameToLayer("Bomb") || gameObject.layer == LayerMask.NameToLayer("InstalledBomb"))
{
GameObject impact = VfxOptimizer.Instance.GetImpact(gameObject.layer);
if (null != impact)
{
Object.Instantiate((Object)impact, hitInfo.point, Quaternion.FromToRotation(Vector3.up, hitInfo.normal));
P2PManager.Instance.SendPEER_HIT_IMPACT(gameObject.layer, hitInfo.point, hitInfo.normal);
}
}
}
}
private void OnLoadComplete()
{
TrainManager.Instance.Load();
for (int i = 0; i < 2; i++)
{
SpawnerDesc spawner = BrickManager.Instance.userMap.GetSpawner(Brick.SPAWNER_TYPE.BOMB_SPAWNER, i);
if (spawner == null)
{
Debug.LogError("Fail to find BOMB SPAWNER from the geometry ");
}
else
{
GameObject brickObjectByPos = BrickManager.Instance.GetBrickObjectByPos(spawner.position);
if (null != brickObjectByPos)
{
BrickProperty component = brickObjectByPos.GetComponent <BrickProperty>();
if (null == component)
{
Debug.LogError("<BombObj> get BrickProperty failed..");
}
else
{
coreObjs[i].transform.position = spawner.position;
coreObjs[i].transform.rotation = brickObjectByPos.transform.rotation;
coreObjs[i].GetComponent <BlastTarget>().Spot = component.Seq;
}
}
}
}
bool flag = false;
if (MyInfoManager.Instance.BreakingInto && MyInfoManager.Instance.BlastModeDesc != null)
{
if (MyInfoManager.Instance.BlastModeDesc.rounding)
{
step = STEP.NOTHING;
bombInstaller = -1;
blastTarget = -1;
flag = false;
}
else if (MyInfoManager.Instance.BlastModeDesc.bombInstaller < 0 || MyInfoManager.Instance.BlastModeDesc.blastTarget < 0)
{
step = STEP.NOTHING;
bombInstaller = -1;
blastTarget = -1;
flag = true;
}
else
{
step = STEP.INSTALLED;
bombInstaller = MyInfoManager.Instance.BlastModeDesc.bombInstaller;
blastTarget = MyInfoManager.Instance.BlastModeDesc.blastTarget;
clockBomb.Install(MyInfoManager.Instance.BlastModeDesc.point, MyInfoManager.Instance.BlastModeDesc.normal);
flag = true;
}
MyInfoManager.Instance.BlastModeDesc = null;
}
if (flag)
{
GlobalVars.Instance.battleStarting = false;
GlobalVars.Instance.senseBombInit();
GameObject gameObject = GameObject.Find("Main");
if (null != gameObject)
{
string text = StringMgr.Instance.Get("WATCHING_USER_CHANGE");
gameObject.BroadcastMessage("OnChat", new ChatText(ChatText.CHAT_TYPE.SYSTEM, -1, string.Empty, text));
}
MyInfoManager.Instance.ControlMode = MyInfoManager.CONTROL_MODE.PLAYING_SPECTATOR;
localController.ResetGravity();
}
else
{
SpawnerDesc spawner2 = BrickManager.Instance.GetSpawner(MyInfoManager.Instance.GetTeamSpawnerType(), MyInfoManager.Instance.Ticket);
if (spawner2 != null)
{
localController.Spawn(spawner2.position, Rot.ToQuaternion(spawner2.rotation));
}
else
{
localController.Spawn(BrickManager.Instance.GetRandomSpawnPos(), Rot.ToQuaternion((byte)UnityEngine.Random.Range(0, 4)));
}
}
if (bRedTeam)
{
if (!MyInfoManager.Instance.GetCommonMask(MyInfoManager.COMMON_OPT.DONOT_EXPLOSION_ATTACK_GUIDE))
{
ExplosionAttackGuideDialog explosionAttackGuideDialog = (ExplosionAttackGuideDialog)DialogManager.Instance.GetDialogAlways(DialogManager.DIALOG_INDEX.EXPLOSION_ATTACK_GUIDE);
if (explosionAttackGuideDialog != null && !explosionAttackGuideDialog.DontShowThisMessageAgain)
{
((ExplosionAttackGuideDialog)DialogManager.Instance.Popup(DialogManager.DIALOG_INDEX.EXPLOSION_ATTACK_GUIDE, exclusive: false))?.InitDialog();
}
}
}
else if (!MyInfoManager.Instance.GetCommonMask(MyInfoManager.COMMON_OPT.DONOT_EXPLOSION_DEFENCE_GUIDE))
{
ExplosionDefenceGuideDialog explosionDefenceGuideDialog = (ExplosionDefenceGuideDialog)DialogManager.Instance.GetDialogAlways(DialogManager.DIALOG_INDEX.EXPLOSION_DEFENCE_GUIDE);
if (explosionDefenceGuideDialog != null && !explosionDefenceGuideDialog.DontShowThisMessageAgain)
{
((ExplosionDefenceGuideDialog)DialogManager.Instance.Popup(DialogManager.DIALOG_INDEX.EXPLOSION_DEFENCE_GUIDE, exclusive: false))?.InitDialog();
}
}
}
