/// <summary>
/// Sets the wall material to the one with the highest material
/// </summary>
private void SetWallMaterial()
{
WallMaterial wallMaterial = null;
int priority = -1;
List <Collider2D> colliders = null;
if (this.hasWallLeft)
{
colliders = this.wallSlideColliderLeft.colliders;
}
else
{
colliders = this.wallSlideColliderRight.colliders;
}
foreach (Collider2D collider in colliders)
{
ObjectMaterial material = collider.gameObject.GetComponent <ObjectMaterial>();
if (material.wallMaterial.priority > priority)
{
wallMaterial = material.wallMaterial;
}
}
this.wallMaterial = wallMaterial;
}
public bool UpgradeObjectByAddition(ObjectMaterial materialToAdd)
{
if (materialToAdd == ObjectMaterial.None)
{
return(false);
}
if (IsUpgradeAllowed(materialToAdd))
{
for (int i = 0; i < 3; i++)
{
if ((ObjectMaterial)VectorMaterial[i] == ObjectMaterial.None)
{
// Try to upgrade using a clone of the material
var tempVector = VectorMaterial;
tempVector[i] = (int)materialToAdd;
var go = mergeableObjectManager.GetObjectFromMaterial(tempVector);
if (go != null)
{
// Upgrade is valid
VectorMaterial = tempVector;
UpdateModel(go, true);
return(true);
}
break;
}
}
}
return(false);
}
// play footstep audio during animation events
void FootstepAudio(RaycastHit hit)
{
ObjectMaterial obMat = hit.collider.GetComponent <ObjectMaterial>();
if (obMat != null)
{
if (obMat.Material == ObjectMaterial.MaterialType.grass)
{
randomizePitch(playerSound);
playerSound.PlayOneShot(grassfootsteps);
}
else if (obMat.Material == ObjectMaterial.MaterialType.wood)
{
randomizePitch(playerSound);
playerSound.PlayOneShot(woodfootsteps);
}
else if (obMat.Material == ObjectMaterial.MaterialType.stone)
{
randomizePitch(playerSound);
playerSound.PlayOneShot(stonefootsteps);
}
else if (obMat.Material == ObjectMaterial.MaterialType.water)
{
randomizePitch(playerSound);
playerSound.PlayOneShot(waterfootsteps);
}
}
}
public override bool StopAnimOnHit(CJObject hit_obj, Collider coll = null)
{
ObjectMaterial component = coll.GetComponent <ObjectMaterial>();
if (hit_obj == null && (component == null || !ObjectMaterial.IsMaterialHard(component.m_ObjectMaterial)))
{
return(false);
}
if (hit_obj != null && hit_obj.GetComponent <AI>() != null)
{
return(false);
}
if (coll != null)
{
Item component2 = coll.gameObject.GetComponent <Item>();
if (component2 != null)
{
if (component2.m_Info != null && component2.m_Info.m_Health <= 0f)
{
this.m_ComboScheduled = false;
this.m_ReleaseComboScheduled = false;
this.m_ReleaseCombo = false;
this.m_ComboBlocked = true;
return(false);
}
if (component2.m_IsPlant)
{
return(false);
}
}
return(true);
}
return(true);
}
private void MakeHitSound(GameObject obj, ItemID item_id)
{
if (this.m_AudioSource == null)
{
this.m_AudioSource = base.gameObject.AddComponent <AudioSource>();
this.m_AudioSource.outputAudioMixerGroup = GreenHellGame.Instance.GetAudioMixerGroup(AudioMixerGroupGame.Player);
}
ObjectMaterial component = obj.GetComponent <ObjectMaterial>();
if (component)
{
AudioClip specificSound = this.GetSpecificSound(item_id, component.m_ObjectMaterial);
if (specificSound)
{
this.m_AudioSource.PlayOneShot(specificSound);
return;
}
}
if (component)
{
int index = UnityEngine.Random.Range(0, this.m_AudioClipsHit[(int)component.m_ObjectMaterial].Count);
AudioClip clip = this.m_AudioClipsHit[(int)component.m_ObjectMaterial][index];
this.m_AudioSource.PlayOneShot(clip);
}
else
{
int index2 = UnityEngine.Random.Range(0, this.m_AudioClipsHit[0].Count);
AudioClip clip2 = this.m_AudioClipsHit[0][index2];
this.m_AudioSource.PlayOneShot(clip2);
}
}
// for cliffs hit
public WeaponHitData(Vector2D hitPosition)
{
this.WorldObject = null;
this.IsCliffsHit = true;
this.FallbackProtoWorldObject = null;
this.FallbackTilePosition = (Vector2Ushort)hitPosition;
this.HitPoint = (hitPosition - this.FallbackTilePosition.ToVector2D()).ToVector2F();
this.FallbackObjectMaterial = ObjectMaterial.Stone;
}
/// <summary>
/// Sets the ground material to the one with the highest material
/// </summary>
private void SetGroundMaterial()
{
GroundMaterial groundMaterial = null;
int priority = -1;
foreach (Collider2D collider in this.onGroundCollider.colliders)
{
ObjectMaterial material = collider.gameObject.GetComponent <ObjectMaterial>();
if (material.groundMaterial.priority > priority)
{
groundMaterial = material.groundMaterial;
}
}
this.groundMaterial = groundMaterial;
}
public WeaponHitSparksPreset Add(
ObjectMaterial material,
double texturePivotY,
TextureAtlasResource texture,
Color?lightColor = null,
bool useScreenBlending = false,
bool allowRandomizedHitPointOffset = true)
{
var frames = ClientComponentSpriteSheetAnimator.CreateAnimationFrames(texture);
this.HitSparksPreset[material] = new HitSparksEntry(frames,
lightColor,
useScreenBlending,
texturePivotY,
allowRandomizedHitPointOffset);
return(this);
}
public static float GetMaterialIndex(ObjectMaterial material)
{
if (material == ObjectMaterial.Lambertian)
{
return(1.0f);
}
else if (material == ObjectMaterial.Metal)
{
return(2.0f);
}
else if (material == ObjectMaterial.Refractive)
{
return(3.0f);
}
return(1.0f);
}
private void AttackTarget(GameObject target, MeleeAttackInfo info)
{
if (!isServer)
{
return;
}
if (target.GetComponent <Health>() != null)
{
target.GetComponent <Health>().Damage(new DamageBase(gameObject, info.Damage));
ObjectMaterial objectMaterial = target.GetComponent <ObjectMaterial>();
RpcDamage(target, info, objectMaterial.HitParticleColorMin, objectMaterial.HitParticleColorMax);
}
if (target.GetComponent <Kickable>() != null)
{
target.GetComponent <Kickable>()
.Kick(new Vector2((int)gameObject.transform.localScale.x * info.Kick.x, info.Kick.y));
}
}
public WeaponHitData(IWorldObject worldObject, Vector2F hitPoint)
{
this.WorldObject = worldObject;
this.IsCliffsHit = false;
this.FallbackProtoWorldObject = worldObject.ProtoWorldObject;
this.FallbackTilePosition = worldObject.TilePosition;
this.HitPoint = hitPoint;
if (worldObject is ICharacter character)
{
this.FallbackObjectMaterial = ((IProtoCharacterCore)character.ProtoCharacter)
.SharedGetObjectMaterialForCharacter(character);
}
else if (worldObject.ProtoWorldObject is IProtoWorldObjectWithSoundPresets protoWorldObjectWithSoundPresets)
{
this.FallbackObjectMaterial = protoWorldObjectWithSoundPresets
.ObjectMaterial;
}
else
{
this.FallbackObjectMaterial = ObjectMaterial.HardTissues;
}
}
public EObjectMaterial GetMaterial()
{
Vector3 vector = base.transform.position + Vector3.up * 0.2f;
int num = Physics.RaycastNonAlloc(vector, Vector3.down * 0.5f, Being.s_RaycastCache);
float num2 = float.MaxValue;
GameObject gameObject = null;
for (int i = 0; i < num; i++)
{
if (Being.s_RaycastCache[i].distance < num2)
{
num2 = Being.s_RaycastCache[i].distance;
gameObject = Being.s_RaycastCache[i].collider.gameObject;
}
}
if (gameObject == null)
{
return(EObjectMaterial.Unknown);
}
if (gameObject.layer == LayerMask.NameToLayer("Water"))
{
return(EObjectMaterial.Water);
}
ObjectMaterial component = gameObject.GetComponent <ObjectMaterial>();
if (component != null)
{
return(component.m_ObjectMaterial);
}
if (gameObject.GetComponent <Terrain>() == null)
{
return(EObjectMaterial.Unknown);
}
TerrainData terrainData = Terrain.activeTerrain.terrainData;
int num3 = (int)(vector.x / terrainData.size.x * (float)terrainData.alphamapWidth);
int num4 = (int)(vector.z / terrainData.size.z * (float)terrainData.alphamapHeight);
if (num3 > terrainData.alphamapWidth || num4 > terrainData.alphamapHeight)
{
return(EObjectMaterial.Grass);
}
float[,,] alphamaps = terrainData.GetAlphamaps(num3, num4, 1, 1);
int num5 = -1;
float num6 = float.MinValue;
for (int j = 0; j < terrainData.alphamapLayers; j++)
{
if (alphamaps[0, 0, j] > num6)
{
num6 = alphamaps[0, 0, j];
num5 = j;
}
}
if (num5 < 0)
{
return(EObjectMaterial.Unknown);
}
switch (num5)
{
case 0:
return(EObjectMaterial.DryLeaves);
case 1:
return(EObjectMaterial.Grass);
case 2:
return(EObjectMaterial.Unknown);
case 3:
return(EObjectMaterial.Grass);
case 4:
return(EObjectMaterial.Mud);
case 5:
return(EObjectMaterial.Soil);
case 6:
return(EObjectMaterial.Stone);
case 7:
return(EObjectMaterial.Sand);
default:
return(EObjectMaterial.Unknown);
}
}
public void OnPlantDestroy()
{
base.enabled = true;
if (!this.m_DontDestroy)
{
base.gameObject.AddComponent <TinyPhysicsObject>();
}
Rigidbody rigidbody = base.gameObject.AddComponentWithEvent <Rigidbody>();
if (rigidbody)
{
rigidbody.collisionDetectionMode = CollisionDetectionMode.Continuous;
}
Collider collider = base.gameObject.GetComponent <Collider>();
if (collider == null)
{
if (this.m_UseApproxBoxCollider)
{
BoxCollider boxCollider = base.gameObject.AddComponent <BoxCollider>();
boxCollider.size = base.GetComponent <Renderer>().bounds.size * 0.5f;
boxCollider.center -= new Vector3(0f, boxCollider.size.y * 0.5f, 0f);
collider = boxCollider;
}
else
{
MeshCollider meshCollider = base.gameObject.AddComponent <MeshCollider>();
meshCollider.convex = true;
collider = meshCollider;
PhysicsDampener physicsDampener = base.gameObject.AddComponent <PhysicsDampener>();
physicsDampener.m_MaxYUpVelocity = 1f;
physicsDampener.m_MaxVelocityMagnitude = 2f;
}
}
this.ReplaceShader(base.gameObject);
ObjectMaterial objectMaterial = base.GetComponent <ObjectMaterial>();
if (objectMaterial == null)
{
objectMaterial = base.gameObject.AddComponent <ObjectMaterial>();
}
objectMaterial.m_ObjectMaterial = EObjectMaterial.Bush;
base.gameObject.layer = this.m_Layer;
if (this.m_ActivateScripts)
{
MonoBehaviour[] components = base.GetComponents <MonoBehaviour>();
for (int i = 0; i < components.Length; i++)
{
components[i].enabled = true;
}
}
else
{
ReplicationComponent component = base.GetComponent <ReplicationComponent>();
if (component)
{
component.enabled = true;
}
}
base.transform.parent = null;
this.DisableCollisionWithPlayer(collider);
this.DisableCollisionWithOtherChunks(collider);
base.gameObject.SetActive(true);
if (base.ReplIsOwner())
{
this.ReplSetDirty();
}
this.m_PlantDestroyed = true;
}
private bool IsUpgradeAllowed(ObjectMaterial materialToAdd)
{
return(CountUnOccupiedMaterials(ref VectorMaterial) >= 1);
}
public void OnDestroyPlant()
{
if (DestroyablePlant.s_StandardShader == null)
{
DestroyablePlant.s_StandardShader = Shader.Find("Custom/WindLeavesC2Standard_not_moving");
}
if (DestroyablePlant.m_Layer == -1)
{
DestroyablePlant.m_Layer = LayerMask.NameToLayer("SmallPlant");
}
List <MeshCollider> list = new List <MeshCollider>();
Dictionary <ItemReplacer, ItemReplacer> dictionary = new Dictionary <ItemReplacer, ItemReplacer>();
for (int i = 0; i < this.m_Chunks.Count; i++)
{
if (!(this.m_Chunks[i] == null) && this.m_Chunks[i].activeSelf)
{
PlantFruit component = this.m_Chunks[i].GetComponent <PlantFruit>();
if (component)
{
ItemID item_id = (ItemID)Enum.Parse(typeof(ItemID), component.m_InfoName);
ItemsManager.Get().CreateItem(item_id, true, this.m_Chunks[i].transform);
}
else
{
GameObject gameObject = UnityEngine.Object.Instantiate <GameObject>(this.m_Chunks[i], this.m_Chunks[i].transform.position, this.m_Chunks[i].transform.rotation);
if (!this.m_DontDestroy)
{
gameObject.AddComponent <TinyPhysicsObject>();
}
gameObject.AddComponent <Rigidbody>();
MeshCollider meshCollider = gameObject.AddComponent <MeshCollider>();
meshCollider.convex = true;
this.ReplaceShader(gameObject);
ObjectMaterial objectMaterial = gameObject.AddComponent <ObjectMaterial>();
objectMaterial.m_ObjectMaterial = EObjectMaterial.Bush;
gameObject.layer = DestroyablePlant.m_Layer;
list.Add(meshCollider);
if (this.m_CopyScripts)
{
this.CopyComponents(this.m_Chunks[i], gameObject);
}
ItemReplacer component2 = this.m_Chunks[i].GetComponent <ItemReplacer>();
ItemReplacer component3 = gameObject.GetComponent <ItemReplacer>();
if (component2 && component3)
{
dictionary[component2] = component3;
}
this.DisableCollisionWithPlayer(meshCollider);
}
}
}
for (int j = 0; j < list.Count; j++)
{
for (int k = j + 1; k < list.Count; k++)
{
Physics.IgnoreCollision(list[j], list[k], true);
}
}
this.SetupItemReplacer(dictionary);
}
public EObjectMaterial GetMaterial()
{
Vector3 position = base.transform.position;
RaycastHit[] array = Physics.RaycastAll(position, Vector3.down * 0.5f);
float num = float.MaxValue;
GameObject gameObject = null;
for (int i = 0; i < array.Length; i++)
{
if (array[i].distance < num)
{
num = array[i].distance;
gameObject = array[i].collider.gameObject;
}
}
if (gameObject == null)
{
return(EObjectMaterial.Unknown);
}
ObjectMaterial component = gameObject.GetComponent <ObjectMaterial>();
if (component != null)
{
return(component.m_ObjectMaterial);
}
if (gameObject.GetComponent <Terrain>() == null)
{
return(EObjectMaterial.Unknown);
}
Terrain activeTerrain = Terrain.activeTerrain;
TerrainData terrainData = activeTerrain.terrainData;
int num2 = (int)(position.x / terrainData.size.x * (float)terrainData.alphamapWidth);
int num3 = (int)(position.z / terrainData.size.z * (float)terrainData.alphamapHeight);
if (num2 > terrainData.alphamapWidth || num3 > terrainData.alphamapHeight)
{
return(EObjectMaterial.Grass);
}
float[,,] alphamaps = terrainData.GetAlphamaps(num2, num3, 1, 1);
int num4 = -1;
float num5 = float.MinValue;
for (int j = 0; j < terrainData.alphamapLayers; j++)
{
if (alphamaps[0, 0, j] > num5)
{
num5 = alphamaps[0, 0, j];
num4 = j;
}
}
if (num4 < 0)
{
return(EObjectMaterial.Unknown);
}
switch (num4)
{
case 0:
return(EObjectMaterial.DryLeaves);
case 1:
return(EObjectMaterial.Grass);
case 2:
return(EObjectMaterial.Unknown);
case 3:
return(EObjectMaterial.Grass);
case 4:
return(EObjectMaterial.Mud);
case 5:
return(EObjectMaterial.Soil);
case 6:
return(EObjectMaterial.Stone);
case 7:
return(EObjectMaterial.Sand);
default:
return(EObjectMaterial.Unknown);
}
}
private void Hit(CJObject cj_object, Collider coll, Vector3 hit_pos, Vector3 hit_dir)
{
Item currentItem = this.m_Player.GetCurrentItem(Hand.Right);
if (cj_object)
{
HumanAI humanAI = null;
AI component = cj_object.GetComponent <AI>();
if (component && component.IsHuman())
{
humanAI = (HumanAI)component;
}
if (humanAI)
{
if (humanAI.m_Hallucination && humanAI.m_HallucinationDisappearing)
{
return;
}
this.HitHumanAI(humanAI, hit_pos, hit_dir);
this.MakeHitSound(coll.gameObject, currentItem.m_Info.m_ID);
this.m_AlreadyHit = true;
}
else
{
Fish component2 = cj_object.GetComponent <Fish>();
if (component2 && component2.m_ID != AI.AIID.AngelFish && component2.m_ID != AI.AIID.DiscusFish && UnityEngine.Random.Range(0f, 1f) < 0.5f)
{
this.m_AlreadyHit = true;
}
else if (base.m_ControllerType == PlayerControllerType.WeaponMelee && component2 && component2.m_ID != AI.AIID.AngelFish && component2.m_ID != AI.AIID.DiscusFish)
{
component2.OnHitByItem(null, hit_pos);
this.MakeHitSound(coll.gameObject, currentItem.m_Info.m_ID);
this.m_AlreadyHit = true;
}
}
if (component)
{
PlayerConditionModule.Get().GetDirtinessAdd(GetDirtyReason.Combat, null);
}
if (!this.m_AlreadyHit)
{
this.HitObject(cj_object, hit_pos, hit_dir);
}
}
else
{
RagdollBone component3 = coll.gameObject.GetComponent <RagdollBone>();
if (component3 && component3.m_ParentObject)
{
DeadBody component4 = component3.m_ParentObject.GetComponent <DeadBody>();
if (component4)
{
component4.OnTakeDamage(new DamageInfo
{
m_DamageItem = currentItem,
m_Damager = base.gameObject,
m_Position = hit_pos,
m_HitDir = hit_dir,
m_Normal = -hit_dir
});
this.m_AlreadyHit = true;
}
}
}
DamageInfo damageInfo = new DamageInfo();
ObjectMaterial component5;
if (cj_object != null)
{
component5 = cj_object.gameObject.GetComponent <ObjectMaterial>();
}
else
{
component5 = coll.gameObject.GetComponent <ObjectMaterial>();
}
EObjectMaterial mat = (component5 == null) ? EObjectMaterial.Unknown : component5.m_ObjectMaterial;
damageInfo.m_Damage = currentItem.m_Info.m_DamageSelf * ObjectMaterial.GetDamageSelfMul(mat);
damageInfo.m_DamageItem = currentItem;
this.MakeHitSound(coll.gameObject, currentItem.m_Info.m_ID);
currentItem.TakeDamage(damageInfo);
this.OnHit();
}
public HitSparksEntry GetForMaterial(ObjectMaterial material)
{
return(this.HitSparksPreset.Find(material));
}
public static void ClientAddHitSparks(
IReadOnlyWeaponHitSparksPreset hitSparksPreset,
WeaponHitData hitData,
IWorldObject hitWorldObject,
IProtoWorldObject protoWorldObject,
Vector2D worldObjectPosition,
int projectilesCount,
ObjectMaterial objectMaterial,
bool randomizeHitPointOffset,
bool randomRotation,
DrawOrder drawOrder,
double scale = 1.0,
double animationFrameDuration = 2 / 60.0)
{
var sceneObject = Api.Client.Scene.CreateSceneObject("Temp_HitSparks");
sceneObject.Position = worldObjectPosition;
var hitPoint = hitData.HitPoint.ToVector2D();
if (!hitData.IsCliffsHit)
{
// move hitpoint a bit closer to the center of the object
hitPoint = WeaponSystem.SharedOffsetHitWorldPositionCloserToObjectCenter(
hitWorldObject,
protoWorldObject,
hitPoint,
isRangedWeapon: randomizeHitPointOffset);
}
var sparksEntry = hitSparksPreset.GetForMaterial(objectMaterial);
if (projectilesCount == 1 &&
randomizeHitPointOffset &&
sparksEntry.AllowRandomizedHitPointOffset)
{
// randomize hitpoint a bit by adding a little random offset
var maxOffsetDistance = 0.2;
var range = maxOffsetDistance * RandomHelper.NextDouble();
var angleRad = 2 * Math.PI * RandomHelper.NextDouble();
var randomOffset = new Vector2D(range * Math.Cos(angleRad),
range * Math.Sin(angleRad));
hitPoint += randomOffset;
}
var componentSpriteRender = Api.Client.Rendering.CreateSpriteRenderer(
sceneObject,
positionOffset: hitPoint,
spritePivotPoint: (0.5, sparksEntry.PivotY),
drawOrder: drawOrder);
componentSpriteRender.DrawOrderOffsetY = -hitPoint.Y;
componentSpriteRender.Scale = (float)scale * Math.Pow(1.0 / projectilesCount, 0.35);
if (sparksEntry.UseScreenBlending)
{
componentSpriteRender.BlendMode = BlendMode.Screen;
}
if (randomRotation)
{
componentSpriteRender.RotationAngleRad = (float)(RandomHelper.NextDouble() * 2 * Math.PI);
}
var componentAnimator = sceneObject.AddComponent <ClientComponentSpriteSheetAnimator>();
var hitSparksEntry = sparksEntry;
componentAnimator.Setup(
componentSpriteRender,
hitSparksEntry.SpriteSheetAnimationFrames,
frameDurationSeconds: animationFrameDuration,
isLooped: false);
var totalAnimationDuration = animationFrameDuration * componentAnimator.FramesCount;
var totalDurationWithLight = 0.15 + totalAnimationDuration;
if (hitSparksEntry.LightColor.HasValue)
{
// create light spot (even for melee weapons)
var lightSource = ClientLighting.CreateLightSourceSpot(
sceneObject,
color: hitSparksEntry.LightColor.Value,
spritePivotPoint: (0.5, 0.5),
size: 7,
// we don't want to display nickname/healthbar for the firing character, it's too quick anyway
logicalSize: 0,
positionOffset: hitPoint);
ClientComponentOneShotLightAnimation.Setup(lightSource, totalDurationWithLight);
}
componentSpriteRender.Destroy(totalAnimationDuration);
componentAnimator.Destroy(totalAnimationDuration);
sceneObject.Destroy(totalDurationWithLight);
}
private void Hit(CJObject cj_object, Collider coll, Vector3 hit_pos, Vector3 hit_dir)
{
Item currentItem = this.m_Player.GetCurrentItem(Hand.Right);
if (cj_object)
{
HumanAI component = cj_object.GetComponent <HumanAI>();
if (component)
{
if (component.m_Hallucination && component.m_HallucinationDisappearing)
{
return;
}
this.HitHumanAI(component, hit_pos, hit_dir);
this.MakeHitSound(coll.gameObject, currentItem.m_Info.m_ID);
this.m_AlreadyHit = true;
return;
}
else
{
this.HitObject(cj_object, hit_pos, hit_dir);
}
}
else
{
RagdollBone component2 = coll.gameObject.GetComponent <RagdollBone>();
if (component2 && component2.m_Parent)
{
DeadBody component3 = component2.m_Parent.GetComponent <DeadBody>();
if (component3)
{
component3.OnTakeDamage(new DamageInfo
{
m_DamageItem = currentItem,
m_Damager = base.gameObject,
m_Position = hit_pos,
m_HitDir = hit_dir,
m_Normal = -hit_dir
});
return;
}
}
}
DamageInfo damageInfo = new DamageInfo();
ObjectMaterial component4;
if (cj_object != null)
{
component4 = cj_object.gameObject.GetComponent <ObjectMaterial>();
}
else
{
component4 = coll.gameObject.GetComponent <ObjectMaterial>();
}
EObjectMaterial mat = (!(component4 == null)) ? component4.m_ObjectMaterial : EObjectMaterial.Unknown;
damageInfo.m_Damage = currentItem.m_Info.m_DamageSelf * ObjectMaterial.GetDamageSelfMul(mat);
damageInfo.m_DamageItem = currentItem;
this.MakeHitSound(coll.gameObject, currentItem.m_Info.m_ID);
currentItem.TakeDamage(damageInfo);
this.OnHit();
}
