private static IEnumerator <float> SpawnGrenadesSurface()
{
yield return(Timing.WaitForSeconds(GrenadeRun.Instance.Config.GrenadeDelaySurface));
while (GrenadeRun.Instance.GrenadeRound)
{
foreach (Exiled.API.Features.Player player in Exiled.API.Features.Player.List)
{
if (player.Role == RoleType.ClassD && player.Position.y > SurfaceBound)
{
GrenadeManager gm = player.ReferenceHub.GetComponent <GrenadeManager>();
GrenadeSettings grenade = gm.availableGrenades.FirstOrDefault(g => g.inventoryID == ItemType.GrenadeFrag);
if (grenade == null)
{
continue;
}
Grenade component = UnityEngine.Object.Instantiate(grenade.grenadeInstance).GetComponent <Grenade>();
component.InitData(gm, Vector3.zero, Vector3.zero, 0f);
NetworkServer.Spawn(component.gameObject);
}
}
yield return(Timing.WaitForSeconds(GrenadeRun.Instance.Config.GrenadeDelaySurface));
}
}
public ThrowData(Character s, Character t, Skill sk, Grenade g)
{
this.source = s;
this.target = t;
this.skill = sk;
this.grenade = g;
}
private void DoGrenade(Grenade grenade)
{
if (null != grenade)
{
float num = grenade.AtkPow / maxAtkPow;
float num2 = grenade.speedFactor / maxMobility;
if (num > 1f)
{
num = 1f;
}
if (num2 > 1f)
{
num2 = 1f;
}
float num3 = num * 100f;
float num4 = num2 * 100f;
DoWeaponPropertyBase();
Color color = GUI.color;
GUI.color = Color.yellow;
TextureUtil.DrawTexture(new Rect(333f, 155f, 104f * num, 12f), gauge, ScaleMode.StretchToFill);
TextureUtil.DrawTexture(new Rect(333f, 235f, 104f * num2, 12f), gauge, ScaleMode.StretchToFill);
GUI.color = color;
LabelUtil.TextOut(new Vector2(390f, 160f), num3.ToString("0.##") + "%", "Label", Color.white, GlobalVars.txtEmptyColor, TextAnchor.MiddleCenter);
LabelUtil.TextOut(new Vector2(390f, 180f), "N/A", "Label", Color.white, GlobalVars.txtEmptyColor, TextAnchor.MiddleCenter);
LabelUtil.TextOut(new Vector2(390f, 200f), "N/A", "Label", Color.white, GlobalVars.txtEmptyColor, TextAnchor.MiddleCenter);
LabelUtil.TextOut(new Vector2(390f, 220f), "N/A", "Label", Color.white, GlobalVars.txtEmptyColor, TextAnchor.MiddleCenter);
LabelUtil.TextOut(new Vector2(390f, 240f), num4.ToString("0.##") + "%", "Label", Color.white, GlobalVars.txtEmptyColor, TextAnchor.MiddleCenter);
LabelUtil.TextOut(new Vector2(390f, 260f), grenade.maxAmmo.ToString(), "Label", Color.white, GlobalVars.txtEmptyColor, TextAnchor.MiddleCenter);
}
}
public void InitLoadout(LoadoutData loadoutRef)
{
Loadout newLoadout = new Loadout();
if (loadoutRef.gun)
{
Gun gun = Instantiate(loadoutRef.gun);
Equip(gun, Anim.GetBoneTransform(HumanBodyBones.RightHand));
newLoadout.gun = gun;
}
if (loadoutRef.grenade)
{
Grenade grenade = Instantiate(loadoutRef.grenade);
Equip(grenade, Vector3.zero, Quaternion.identity);
newLoadout.grenade = grenade;
}
if (loadoutRef.gadget)
{
Gadget gadget = Instantiate(loadoutRef.gadget);
Equip(gadget, Vector3.zero, Quaternion.identity);
newLoadout.gadget = gadget;
}
loadout = newLoadout;
}
void DamageTargets()
{
Collider[] colliders = Physics.OverlapSphere(transform.position, explosionRadius);
foreach (Collider collider in colliders)
{
Rigidbody rb = collider.attachedRigidbody;
if (rb != null)
{
rb.AddExplosionForce(Damage * explosionRadius, transform.position, explosionRadius);
}
GameObject parent = collider.gameObject;
if (parent != null)
{
Grenade g = parent.GetComponent <Grenade>();
StateController controller = parent.GetComponent <StateController>();
if (controller != null)
{
float thrownDistance = Vector3.Distance(startPos, finalPos);
controller.DoDamage(Damage);
if (score != null)
{
score.UpdateScore(Mathf.RoundToInt(Damage * thrownDistance));
}
}
if (g != null && !g.hasExploded)
{
g.Explode();
}
}
}
}
internal void PlayerDeath(ref PlayerDeathEvent ev)
{
if (plugin.curMod.HasFlag(ModType.NONE) && plugin.enabledTypes.Contains(ModType.NONE))
{
return; // cuz none means none
}
if (plugin.curMod.HasFlag(ModType.EXPLODEONDEATH) && plugin.enabledTypes.Contains(ModType.EXPLODEONDEATH))
{
if (ev.Killer == null || (ev.Killer != null && ev.Killer.GetTeam() != Team.SCP && ev.Killer.GetTeam() != Team.TUT))
{
GrenadeManager gm = ev.Player.GetComponent <GrenadeManager>();
GrenadeSettings set = gm.availableGrenades.FirstOrDefault(g => g.inventoryID == ItemType.GrenadeFrag);
if (set == null)
{
}
else
{
Grenade comp = UnityEngine.Object.Instantiate(set.grenadeInstance).GetComponent <Grenade>();
comp.fuseDuration = 0.1f;
comp.InitData(gm, Vector3.zero, Vector3.zero, 10f);
// commented for stable release
//deathGrenades.Add(comp);
NetworkServer.Spawn(comp.gameObject);
}
}
}
if (plugin.curMod.HasFlag(ModType.CLASSINFECT) && plugin.enabledTypes.Contains(ModType.CLASSINFECT))
{
if (ev.Killer != null && ev.Killer != ev.Player && !plugin.noInfectRoles.Contains(ev.Killer.characterClassManager.CurClass))
{
Timing.RunCoroutine(InfectLate(ev.Player, ev.Killer.characterClassManager.CurClass, ev.Killer.transform.position));
}
}
}
void UpdateFiring()
{
if (m_GrenadeObject == null)
{
return;
}
if (Input.GetButtonDown("Fire1"))
{
Vector3 direction = new Vector3(1.0f, 0.0f, 0.0f);
Vector3 bankingAxis = new Vector3(0.0f, 1.0f, 0.0f);
direction = Quaternion.AngleAxis(m_CurrentDesiredAngle, bankingAxis) * direction;
Vector3 horizonAxis = Vector3.Cross(direction, bankingAxis);
direction = Quaternion.AngleAxis(45.0f, horizonAxis) * direction;
Vector3 startVelocity = direction * m_CurrentDesiredSpeed;
// spawn a grenade
GameObject temp = GameObject.Instantiate(m_GrenadeObject);
temp.transform.position = new Vector3(0.0f, 0.0f, 0.0f);
Grenade grenade = temp.GetComponent <Grenade>();
grenade.m_Gravity = m_Gravity;
grenade.m_CurrentVelocity = startVelocity;
grenade.enabled = true;
}
}
public void FirePhysicsProjectile(Transform spawnLocation, Vector3 targetLocation, float force)
{
// TODO: Make spawned projectile a saveable object
GameObject spawnedProjectile = Instantiate(physicsProjectile, spawnLocation.position, spawnLocation.rotation);
spawnedProjectile.transform.LookAt(targetLocation);
// If the spawnedProjectile is a grenade, set character
Grenade grenade = spawnedProjectile.GetComponent <Grenade>();
if (grenade != null)
{
grenade.character = character;
}
// Spread
Vector3 spreadTransform = new Vector3(Random.Range(-spread, spread), Random.Range(-spread, spread), 0);
spawnedProjectile.transform.rotation = spawnedProjectile.transform.rotation * Quaternion.Euler(spreadTransform);
Rigidbody rb = spawnedProjectile.GetComponent <Rigidbody>();
if (rb)
{
rb.AddForce(spawnedProjectile.transform.forward * force);
}
}
public void ReceiveGrenade(Grenade thrownGrenade)
{
thrownGrenade.SetPosition(Position + armOffset + new Vector3(leftOrRight * myGrenades.Count, 0, 0));
myGrenades.Add(thrownGrenade);
myGrenades[0].SetPosition(Position + armOffset);
thrownGrenade.OnExploded.AddListener(grenadeExploded);
}
/// <inheritdoc/>
public void C4Handler(Grenade charge, C4RemoveMethod removeMethod = C4RemoveMethod.Detonate)
{
switch (removeMethod)
{
case C4RemoveMethod.Remove:
{
NetworkServer.Destroy(charge.gameObject);
break;
}
case C4RemoveMethod.Detonate:
{
charge.NetworkfuseTime = 0.1f;
break;
}
case C4RemoveMethod.Drop:
{
TrySpawn((int)Id, charge.transform.position);
NetworkServer.Destroy(charge.gameObject);
break;
}
}
PlacedCharges.Remove(charge);
}
public void MoveGrenade(Grenade g)
{
GameObject obj = GrenadeToGameObj[g];
obj.transform.position = g.Position;
/*
* if (Vector3.Distance(obj.transform.position, g.Position) > 0)
* {
* // Do curve
* Vector3 start = obj.transform.position;
* Vector3 end = g.Position + grenadeArmOffset;
* var points = new Vector3[] {
* start,
* new Vector3(start.x+(end.x-start.x)/2,(end.y-start.y)+3,start.z),
* end
* };
* var path = new GoSpline(points);
* gAnim = obj.GetComponent<Animator>();
* gAnim.SetTrigger("isMoving");
* GoTween gt = Go.to(obj.transform, 1f, new GoTweenConfig().positionPath(path, false));
* gt.setOnCompleteHandler(t =>
* {
* grenadeSettle(g);
* });
* }
*/
}
void RegisterGrenade(Grenade g)
{
sources[g] = Camera.main.gameObject.AddComponent <AudioSource>();
sources[g].volume = soundVolume;
g.OnThrown.AddListener(GrenadeThrow);
g.OnExploded.AddListener(GrenadeExploded);
}
/* --- Additional Methods --- */
void Throw()
{
if (isBackSwinging)
{
}
else if (isSwinging)
{
if (!hasThrown)
{
// The path
Vector2 A = holderState.targetPosition;
Vector2 B = holderState.transform.position;
if (Vector2.Distance(A, B) > throwRange)
{
A = (A - B).normalized * throwRange + B;
}
// The exploder
Grenade exploder = Instantiate(exploderPrefab, skeleton.head.transform.position, Quaternion.identity, null).GetComponent <Grenade>();
exploder.gameObject.SetActive(true);
exploder.SetPath(A, B, arcHeight, throwSpeed);
exploder.GetComponent <SpriteRenderer>().enabled = true;
hasThrown = true;
}
}
else if (isResetting)
{
hasThrown = false;
}
}
void FixedUpdate()
{
Grenade ent = gameObject.GetComponent <Grenade>();
if (ent.speed > 0 || ent.spawned)
{
return;
}
ent.spawned = true;
GameObject expl = Instantiate(explosion, gameObject.transform.position, Quaternion.identity);
Destroy(expl, 0.5f);
Collider2D[] hitList = Physics2D.OverlapCircleAll(transform.position, radius);
foreach (Collider2D entity in hitList)
{
if (entity.name.Contains("zombie") || entity.name.Contains("boss"))
{
entity.GetComponent <zombieStats>().setDamage(GlobalVar.instance.getBombDamage());
}
else if (entity.name.Contains("player"))
{
HealthSystem.instance.Damage(gameObject.GetComponent <Grenade>().damage * 5);
}
}
}
private void OnThrowingGrenade(ThrowingGrenadeEventArgs ev)
{
if (CheckItem(ev.Player.CurrentItem))
{
ev.IsAllowed = false;
Grenade grenadeComponent = ev.Player.GrenadeManager.availableGrenades[0].grenadeInstance.GetComponent <Grenade>();
Timing.CallDelayed(1f, () =>
{
Vector3 pos = ev.Player.CameraTransform.TransformPoint(grenadeComponent.throwStartPositionOffset);
if (ExplodeOnCollision)
{
var grenade = SpawnGrenade(pos, ev.Player.CameraTransform.forward * 9f, 1.5f, GetGrenadeType(ItemType)).gameObject;
CollisionHandler collisionHandler = grenade.gameObject.AddComponent <CollisionHandler>();
collisionHandler.owner = ev.Player.GameObject;
collisionHandler.grenade = grenadeComponent;
TrackedGrenades.Add(grenade);
}
else
{
SpawnGrenade(pos, ev.Player.CameraTransform.forward * 9f, FuseTime, GetGrenadeType(ItemType));
}
ev.Player.RemoveItem(ev.Player.CurrentItem);
});
}
}
/// <summary>
/// Load the grenade
/// </summary>
public override void Load()
{
Grenade grenade = GameResources.GetInstance().Get <Grenade>();
grenadeHolder.AddChild(grenade);
this.WeaponAmmo = grenade;
}
/// <summary>
/// Starts the item use.
/// </summary>
/// <param name="itemAbility">The item ability that is using the item.</param>
public override void StartItemUse(ItemAbility itemAbility)
{
base.StartItemUse(itemAbility);
// An Animator Audio State Set may prevent the item from being used.
if (!IsItemInUse())
{
return;
}
// Grenades can be cooked (and explode while still in the character's hands).
m_InstantiatedGrenade = m_InstantiatedTrajectoryObject as Grenade;
m_InstantiatedGrenade.StartCooking(m_Character);
// If a pin is specified then it can optionally be removed when the grenade is being thrown.
if (m_InstantiatedGrenade.Pin != null)
{
if (m_AnimatePinRemoval && !m_DisableVisibleObject)
{
if (m_RemovePinEvent.WaitForAnimationEvent)
{
EventHandler.RegisterEvent(m_Character, "OnAnimatorItemRemovePin", RemovePin);
}
else
{
Scheduler.ScheduleFixed(m_RemovePinEvent.Duration, RemovePin);
}
}
}
}
void Start()
{
healthBar = gameObject.transform.Find("HealthBar");
hb_max = health;
local_scale_x = healthBar.transform.localScale.x;
au_sou = GetComponent <AudioSource>();
boss_die = Resources.Load <AudioClip>("Boss_die");
boss_shot = Resources.Load <AudioClip>("Boss_shot");
boss_hit = Resources.Load <AudioClip>("Boss_hurt");
boss_throw = Resources.Load <AudioClip>("Boss_throw");
boss_knife = Resources.Load <AudioClip>("Boss_knife");
box = GetComponent <BoxCollider2D>();
myRigidBody = GetComponent <Rigidbody2D>();
sprite = GetComponent <SpriteRenderer>();
animate = GetComponent <Animator>();
polygon = GetComponentInChildren <PolygonCollider2D>();
character = FindObjectOfType <charChange>();
man = GameObject.Find("Man").GetComponent <Player>().transform;
robot = GameObject.Find("Robot").GetComponent <Player>().transform;
projectile = gunProjectile.GetComponent <Projectile>();
grenade = grenadeObject.GetComponent <Grenade>();
isShooting = false;
polygon.enabled = false;
state = State.Walking;
gravity = -gravitySpeed / 100;
projectile.speed = projectileSpeed;
projectile.damage = projectileDamage;
grenade.throwDistance = throwDistance;
grenade.explosionDelay = explosionDelay;
bossDeath = false;
}
void Update()
{
healthBar.SetHealth(hitPoints);
CalculateCrosshairPosition();
if (alive)
{
Movment();
if (Keyboard.current.gKey.isPressed && Time.time > nextGrenade)
{
nextGrenade = Time.time + 1f;
Grenade newGrenade = Instantiate(grenade, new Vector3(transform.position.x, transform.position.y + 1f, transform.position.z), Quaternion.identity) as Grenade;
newGrenade.CalculatePath(this.transform, crosshairPosition);
}
if (Mouse.current.leftButton.isPressed)
{
isShooting = 1;
equipedWeapon.Fire(crosshairPosition);
}
else
{
isShooting -= 0.05f;
}
playerAnimator.SetFloat("isShooting", isShooting);
}
}
override protected void InitSkills(Transform owner)
{
Skill.SetGST(GameObject.Find("Manager").GetComponent <GlobalScriptTeam>());
Transform attackPoint = owner.GetChild(2);
Fist fist = new Fist(owner, "Fist", 10, 1, 0, 1f, Skill.SkillType.Melee, attackPoint, 100);
Shuriken shuriken = new Shuriken(owner, "Shuriken", 25, 3, 10, 3f, Skill.SkillType.Ranged, 1000, 4, attackPoint);
Grenade grenade = new Grenade(owner, "Grenade", 35, 12, 15, 10, Skill.SkillType.Ranged, 500, 5, attackPoint);
_skills.set((int)AbilityType.Stype.None, fist);
_skills.set((int)AbilityType.Stype.None, shuriken);
_skills.set((int)AbilityType.Stype.None, grenade);
FireBall fireBall = new FireBall(owner, "FireBall", 35, 3, 15, 3f, Skill.SkillType.Ranged, 1000, 4, attackPoint);
_skills.set((int)AbilityType.Stype.Fire, fist);
_skills.set((int)AbilityType.Stype.Fire, fireBall);
Tornado tornado = new Tornado(owner, "Tornado", 100, 0, 20, 15, Skill.SkillType.OnArea, 5, 5);
_skills.set((int)AbilityType.Stype.Wind, fist);
_skills.set((int)AbilityType.Stype.Wind, tornado);
}
public void cmd_ball(CommandInfo info)
{
Vector3 NULL_VECTOR = new Vector3(0, 0, 0);
List <GameObject> playerList = GetPlayersFromString(info.commandArgs[1]);
foreach (GameObject plr in playerList)
{
if (plr.GetComponent <CharacterClassManager>().CurClass == RoleType.Spectator)
{
continue;
}
PheggPlayer pp = new PheggPlayer(plr);
// Initialization
GrenadeManager gm = pp.gameObject.GetComponent <GrenadeManager>();
// Finalize creation & Spawn
Grenade nade = Object.Instantiate <GameObject>(gm.availableGrenades[2].grenadeInstance).GetComponent <Grenade>();
(nade).InitData(gm, NULL_VECTOR, NULL_VECTOR);
NetworkServer.Spawn(nade.gameObject);
}
info.commandSender.RaReply(info.commandName.ToUpper() + $"#Spawned 018 on {(info.commandArgs[1] == "*" ? "All" : playerList.Count.ToString())} players", true, true, "");
}
public void OnDied(DiedEventArgs ev)
{
if (Tracking.PlayersInvisibleByCommand.Contains(ev.Target))
{
Tracking.PlayersInvisibleByCommand.Remove(ev.Target);
}
if (Tracking.PlayersWithSubclasses.ContainsKey(ev.Target) && Tracking.PlayersWithSubclasses[ev.Target].Abilities.Contains(AbilityType.ExplodeOnDeath))
{
GrenadeManager grenadeManager = ev.Target.ReferenceHub.gameObject.GetComponent <GrenadeManager>();
GrenadeSettings settings = grenadeManager.availableGrenades.FirstOrDefault(g => g.inventoryID == ItemType.GrenadeFrag);
Grenade grenade = UnityEngine.Object.Instantiate(settings.grenadeInstance).GetComponent <Grenade>();
grenade.fuseDuration = Tracking.PlayersWithSubclasses[ev.Target].FloatOptions.ContainsKey("ExplodeOnDeathFuseTimer") ?
Tracking.PlayersWithSubclasses[ev.Target].FloatOptions["ExplodeOnDeathFuseTimer"] : 2f;
grenade.FullInitData(grenadeManager, ev.Target.Position, Quaternion.Euler(grenade.throwStartAngle),
grenade.throwLinearVelocityOffset, grenade.throwAngularVelocity);
NetworkServer.Spawn(grenade.gameObject);
}
Tracking.AddPreviousTeam(ev.Target);
Tracking.RemoveZombie(ev.Target);
Tracking.RemoveAndAddRoles(ev.Target, true);
Timing.CallDelayed(0.1f, () => {
Tracking.CheckRoundEnd();
});
}
void Start()
{
rb = GetComponent <Rigidbody>();
startingPosition = transform.position;
grenadeScript = GetComponent <Grenade>();
windForce = 0;
}
// Use this for initialization
void Start()
{
_grenadeScript = FindObjectOfType <Grenade>();
_shootingScript = FindObjectOfType <PlayerShooting>();
_mainWeaponTimerText = mainWeapon.GetComponentInChildren <Text>();
_specialWeaponTimerText = specialWeapon.GetComponentInChildren <Text>();
}
/// <inheritdoc/>
public override Grenade Spawn(Vector3 position, Vector3 velocity, float fuseTime = 3, ItemType grenadeType = ItemType.GrenadeFrag, Player player = null)
{
if (player == null)
{
player = Server.Host;
}
GrenadeManager grenadeManager = player.GrenadeManager;
GrenadeSettings settings =
grenadeManager.availableGrenades.FirstOrDefault(g => g.inventoryID == grenadeType);
Grenade grenade = GameObject.Instantiate(settings.grenadeInstance).GetComponent <Grenade>();
grenade.FullInitData(grenadeManager, position, Quaternion.Euler(grenade.throwStartAngle), velocity, grenade.throwAngularVelocity, player == Server.Host ? Team.RIP : player.Team);
grenade.NetworkfuseTime = NetworkTime.time + fuseTime;
Tracked.Add(grenade.gameObject);
GameObject grenadeObject = grenade.gameObject;
UnityEngine.Object.Destroy(grenadeObject.GetComponent <Scp018Grenade>());
grenadeObject.AddComponent <Components.Rock>().Init(player.GameObject, player.Side, FriendlyFire, ThrownDamage);
NetworkServer.Spawn(grenadeObject);
if (ExplodeOnCollision)
{
grenade.gameObject.AddComponent <CollisionHandler>().Init(player.GameObject, grenade);
}
return(grenade);
}
override protected void PrimeTimeFinished()
{
// spawn child grenades
PackedScene _projectileScene = (PackedScene)ResourceLoader.Load(MIRVGrenade.MIRVResource);
Grenade[] mirvs = new Grenade[4];
Random ran = new Random();
for (int i = 0; i < 4; i++)
{
// spawn projectile, set it moving
Grenade _projectileMesh = (Grenade)_projectileScene.Instance();
// add to scene
GetNode("/root/OpenFortress/Main").AddChild(_projectileMesh);
Vector3 dir = new Vector3(ran.Next(150), ran.Next(150), ran.Next(150));
_projectileMesh.MIRVInit(this.GetGlobalTransform(), _playerOwner, "mirvgrenade", 20, 100, dir);
mirvs[i] = _projectileMesh;
}
// make sure they don't just bounce on each other and float in air
for (int i = 0; i < 4; i++)
{
for (int i2 = 0; i2 < 4; i2++)
{
if (i2 != i)
{
mirvs[i].AddCollisionExceptionWith(mirvs[i2]);
}
}
}
// now have original mirv explode
this.Explode(_damage);
}
/**
* @brief
* metoda odpowiadajaca za instancjonowanie prefaba pocisku/ów i ustawienie kierunku w jakim ma byc wystrzelony
*/
protected override void Shoot()
{
GameObject gobject = Instantiate(bulletPrefab, firePoint.position, firePoint.rotation);
Grenade grenade = gobject.GetComponent <Grenade>();
float mouseDistance = (firePoint.position - new Vector3(mousePosition.x, mousePosition.y)).magnitude;
grenade.range = mouseDistance > grenade.range ? grenade.range : mouseDistance;
}
void GrenadeThrow(Vector2 _dir)
{
GameObject _grenade = Instantiate(playerGrenade, (new Vector3(_dir.x, _dir.y, 0) * 1.5f + transform.position), Quaternion.identity);
Grenade _grenadeProp = _grenade.GetComponent <Grenade>();
_grenadeProp.targetDir = _dir.normalized * bulletSpeed;
GameManager.instance.ShakeCamera(2f, 5);
}
private void OnEnable()
{
grenade = Instantiate(grenadePrefab, transform.position, transform.rotation);
Destroy(grenade.GetComponent <Rigidbody>());
grenade.transform.parent = gameObject.transform;
_grenadeScript = grenade.GetComponent <Grenade>();
timeElapsed = 0f;
}
void Ammu()
{
Grenade kranu = new Grenade(4.0, TimeSpan.FromSeconds(0.7));
pelaaja.Throw(kranu, Angle.FromDegrees(10), 5000);
kranu.Explosion.Force = 100;
kranu.Explosion.MaxRadius = 70;
kranu.Explosion.AddShockwaveHandler("vihollinen", KranuOsui);
}
void Update()
{
if (Input.GetButtonDown("Grenade") && heldGrenade == null && grenadeAmmo > 0) {
heldGrenade = BoltNetwork.Instantiate(BoltPrefabs.Grenade).GetComponent<Grenade>();
heldGrenade.SetThrower(GameManager.instance.CurrentUserName);
heldGrenade.transform.parent = this.transform;//the grenade needs to follow us if we move while cooking it
heldGrenade.transform.localPosition = new Vector3(0f,0f,3f);//put it in front of the player for now
heldGrenade.transform.localRotation = Quaternion.identity;
heldGrenade.transform.localScale = Vector3.one;
heldGrenade.GetComponent<Rigidbody>().isKinematic = true;
grenadeAmmo--;
}
if (Input.GetButtonUp("Grenade") && heldGrenade != null) {
Rigidbody rgb = heldGrenade.GetComponent<Rigidbody>();
rgb.isKinematic = false;
rgb.AddForce(transform.forward * ThrowForce);
heldGrenade.transform.parent = null;
heldGrenade.GetComponent<Collider>().enabled = true;
heldGrenade = null;
}
}
public override CastleButcher.GameEngine.IMissile GetMissile(object owner, Framework.MyMath.MyVector position, Framework.MyMath.MyQuaternion orientation)
{
IMissile missile = new Grenade(1, owner, this, position, orientation, (new MyVector(0, 0, -1)).Rotate(orientation) * this.flyingObjectParameters.MaxVelocity);
return missile;
}
private void GrenadeExplosion(Grenade grenade, CollisionParameters parameters)
{
float maxDistance = grenade.ImpactDamage/4;
float impactDamage = grenade.ImpactDamage;
if (OnGrenadeHit != null)
OnGrenadeHit(grenade, parameters.CollisionPoint);
RemoveObject((IGameObject)grenade);
for (int i = 0; i < players.Count; i++)
{
if (players[i].IsAlive)
{
MyVector pos = players[i].CurrentCharacter.Position;
if ((pos - parameters.CollisionPoint).Length < maxDistance)
{
int damage = (int)(impactDamage * ((pos - parameters.CollisionPoint).Length / maxDistance));
players[i].OnMissileHit(grenade, parameters);
if (remote)
damage = 0;
if (players[i].CurrentCharacter.TakeDamage(damage))
{
((Character)grenade.Owner).Player.OnEnemyDestroyed(players[i]);
World.Instance.PlayerKilled(players[i]);
}
}
}
}
}
protected override void LoadContent()
{
spriteBatch = new SpriteBatch(GraphicsDevice);
device = graphics.GraphicsDevice;
backgroundTexture = Content.Load<Texture2D>("gamebg");
screenWidth = device.PresentationParameters.BackBufferWidth;
screenHeight = device.PresentationParameters.BackBufferHeight;
foregroundTexture = Content.Load<Texture2D>("foreground");
SetUpPlayers();
armyTexture = Content.Load<Texture2D>("army2");
Grenade gre = new Grenade();
GrenadeBuilder grenade = new GrenadeBuilder(gre);
grenade.build();
Rocket roc = new Rocket();
RocketBuilder rocket = new RocketBuilder(roc);
rocket.build();
playerScaling = 40.0f / (float)armyTexture.Width;
}
void Instance_OnGrenadeHit(Grenade grenade, MyVector position)
{
renderer.MakeExplosion(position, grenade.ImpactDamage);
SoundSystem.SoundEngine.PlaySound(SoundSystem.Enums.SoundTypes.explode, (Vector3)position);
}
public ThrowGrenade( Unit owner, Grenade source )
: base(owner, source, "ThrowGrenade")
{
oneUse = true;
}
void HeitaPommi()
{
Grenade pommi = new Grenade(10.5); //luodaan pommi
pommi.Image = pomminKuva; //asetetaan sille tekstuurit
pelaaja.Throw(pommi, Angle.FromDegrees(30), 1);//heitetään se
pommi.Explosion.ShockwaveReachesObject += KranaattiOsui; //collisionhandler
}
