void OnTriggerEnter(Collider other)
{
if (other.gameObject.tag == "Flash")
{
StopAllCoroutines();
StartCoroutine(IsStunned());
}
if (other.gameObject.tag == "Player" && other.gameObject.GetComponent <PlayerController>() != null)
{
playerController = other.gameObject.GetComponent <PlayerController>();
if (stunned && other.gameObject.transform.position.y >= transform.position.y && !playerController.IsGrounded())
{
playerController.BounceUsingForce(playerBounceDistance);
TakeDamage();
}
else if (other.gameObject.GetComponent <PlayerHurt>() != null)
{
int direction = 1;
PathCreator currentSpline = GetComponent <SplineWalker>().currentSpline;
float splineDist = currentSpline.path.GetClosestDistanceAlongPath(transform.position);
float playerPos = currentSpline.path.GetClosestDistanceAlongPath(other.gameObject.transform.position);
if (playerPos > splineDist)
{
direction = -1;
}
playerHurt = other.gameObject.GetComponent <PlayerHurt>();
HurtPlayer(damage, direction);
}
}
}
public static void HandleData(GetDataEventArgs args, MemoryStream data, PvPPlayer player)
{
switch (args.MsgID)
{
case PacketTypes.PlayerHurtV2:
PlayerHurt?.Invoke(typeof(DataHandler), new PlayerHurtArgs(args, data, player));
return;
case PacketTypes.TogglePvp:
PvPToggled?.Invoke(typeof(DataHandler), new TogglePvPArgs(player));
return;
case PacketTypes.PlayerSlot:
PlayerSlotUpdated?.Invoke(typeof(DataHandler), new PlayerSlotArgs(data, player));
return;
case PacketTypes.PlayerDeathV2:
PlayerDied?.Invoke(typeof(DataHandler), new PlayerDeathArgs(player));
return;
case PacketTypes.ProjectileNew:
ProjectileNew?.Invoke(typeof(DataHandler), new ProjectileNewArgs(args, data, player));
return;
case PacketTypes.ProjectileDestroy:
ProjectileDestroyed?.Invoke(typeof(DataHandler), new ProjectileDestroyArgs(data));
return;
case PacketTypes.PlayerUpdate:
PlayerUpdated?.Invoke(typeof(DataHandler), new PlayerUpdateArgs(data, player));
return;
}
}
private WeaponFireGraphics CreateWeaponFireGraphics(PlayerHurt playerHurt, int playbackScale, Vector3 mapOffset)
{
var weaponFireClone = Instantiate(WeaponGraphicsManager.Instance.WeaponFirePrefab);
var weaponGraphics = weaponFireClone.GetComponent <WeaponFireGraphics>();
var startPoint = (playerHurt.Attacker.Position / playbackScale) - mapOffset + PlayersManager.HeadOffset;
weaponGraphics.HasEndPoint = true;
var endPoint = (playerHurt.Victim.Position / playbackScale) - mapOffset;
if (playerHurt.HitGroup == Hitgroup.Head)
{
endPoint += PlayersManager.HeadOffset;
}
if (GraphicsManager.Instance.PlaybackMode == PlaybackMode.TwoD)
{
startPoint.y = endPoint.y = 0.3f;
}
weaponGraphics.StartPoint = startPoint;
weaponGraphics.EndPoint = endPoint;
weaponGraphics.EmissionColor = new Color(1, 0.2946248f, 0.2132353f);
return(weaponGraphics);
}
void OnCollisionEnter(Collision collider)
{
PlayerHurt player = collider.gameObject.GetComponent <PlayerHurt>();
if (player)
{
player.DoDamage(m_DamageAmount);
}
}
public static void HandleData(GetDataEventArgs args, MemoryStream data, PvPPlayer player)
{
switch (args.MsgID)
{
case PacketTypes.PlayerHurtV2:
if (new PlayerHurtArgs().ExtractData(args, data, player, out var playerhurt))
{
PlayerHurt?.Invoke(typeof(DataHandler), playerhurt);
}
return;
case PacketTypes.TogglePvp:
if (new TogglePvPArgs().ExtractData(player, out var togglepvp))
{
PvPToggled?.Invoke(typeof(DataHandler), togglepvp);
}
return;
case PacketTypes.PlayerSlot:
if (new PlayerSlotArgs().ExtractData(data, player, out var playerslot))
{
SlotUpdate?.Invoke(typeof(DataHandler), playerslot);
}
return;
case PacketTypes.PlayerDeathV2:
if (new PlayerDeathArgs().ExtractData(player, out var playerdeath))
{
PlayerDeath?.Invoke(typeof(DataHandler), playerdeath);
}
return;
case PacketTypes.ProjectileNew:
if (new ProjectileNewArgs().ExtractData(args, data, player, out var projectilenew))
{
ProjectileNew?.Invoke(typeof(DataHandler), projectilenew);
}
return;
case PacketTypes.ProjectileDestroy:
if (new ProjectileDestroyArgs().ExtractData(data, out var projectiledestroy))
{
ProjectileDestroyed?.Invoke(typeof(DataHandler), projectiledestroy);
}
return;
case PacketTypes.PlayerUpdate:
if (new PlayerUpdateArgs().ExtractData(data, player, out var playerupdate))
{
PlayerUpdate?.Invoke(typeof(DataHandler), playerupdate);
}
return;
}
}
public void OnPlayerHurt(object sender, object e)
{
if (!_parser.MatchStarted)
{
return;
}
var eventArgs = (PlayerHurtEventArgs)e;
var parser = (DemoParser)sender;
var playerHurt = new PlayerHurt()
{
Victim = new PartialPlayer(eventArgs.Player),
Weapon = new PartialWeapon(eventArgs.Weapon),
HitGroup = eventArgs.Hitgroup
};
if (eventArgs.Attacker != null)
{
playerHurt.Attacker = new PartialPlayer(eventArgs.Attacker);
}
else
{
playerHurt.IsFallDamage = true;
}
PlayerHurtFrame frame = null;
if (PlaybackManager.Instance.PlayerHurtFrames.Any())
{
frame = PlaybackManager.Instance.PlayerHurtFrames.Last();
}
if (frame == null || frame.Tick != parser.CurrentTick)
{
frame = new PlayerHurtFrame()
{
Tick = parser.CurrentTick,
PlayerHurts = new List <PlayerHurt>()
{
playerHurt
}
};
PlaybackManager.Instance.PlayerHurtFrames.Add(frame);
}
else
{
frame.PlayerHurts.Add(playerHurt);
}
}
private void Start()
{
playerRigidbody = GetComponent <Rigidbody2D>();
animator = GetComponentInChildren <Animator>();
stateMachine = gameObject.AddComponent(typeof(StateMachine)) as StateMachine;
idleState = new PlayerIdle(this, stateMachine);
hurtState = new PlayerHurt(this, stateMachine);
deadState = new PlayerDead(this, stateMachine);
bounceVelocity = Vector3.zero;
bounceTimer = maxBounceTime;
hurtTimer = maxHurtTime;
stateMachine.SetState(idleState);
mainCamera = Camera.main;
transform = gameObject.transform;
}
public static void InvokePlayerHurt(PlayerStats stats, ref PlayerStats.HitInfo info, GameObject obj, int pid = 0)
{
PlayerHurt playerHurt = PlayerHurtEvent;
if (playerHurt == null)
{
return;
}
PlayerHurtEvent ev = new PlayerHurtEvent
{
Attacker = pid == 0 ? stats.gameObject.GetPlayer() : Player.GetPlayer(pid),
Player = obj.GetPlayer(),
Info = info
};
if (string.IsNullOrEmpty(ev.Player.characterClassManager.UserId))
{
return;
}
playerHurt.Invoke(ref ev);
info = ev.Info;
}
// void Start()
// {
//
// }
private void OnEnable()
{
var obj = GameObject.Find("NPC2");
if (!obj)
{
_aiChanger.ChangeAi();
return;
}
_target = obj.transform;
_player = _target.gameObject.GetComponent <PlayerHurt>();
var warFace = GetComponentInChildren <ChangeFace>();
if (warFace)
{
warFace.MakeEvil();
}
_gun = GetComponentInChildren <ParticleSystem>();
_rigidbody = GetComponent <Rigidbody>();
_rigidbody.velocity = Vector3.zero;
}
public void RegisterToPlayerHurt(PlayerHurt function)
{
OnPlayerHurt += function;
}
public void PreprocessData(ReplayGamestate gamestate, MapMetaData mapmeta, EncounterDetectionData edData)
{
// Load and create standard data
base.PreprocessMain(gamestate, mapmeta, edData);
// Custom preprocessing for your game
#region Collect positions for preprocessing and build hashtables of events
var positions = new HashSet <Point3D>();
List <double> hurt_ranges = new List <double>();
List <double> support_ranges = new List <double>();
foreach (var round in gamestate.Match.Rounds)
{
foreach (var tick in round.ticks)
{
foreach (var gevent in tick.getTickevents())
{
switch (gevent.GameeventType) //Build hashtables with events we need later
{
case "player_hurt":
PlayerHurt ph = (PlayerHurt)gevent;
// Remove Z-Coordinate because we later get keys from clusters with points in 2D space -> hashtable needs keys with 2d data
edData.Hit_hashtable[ph.Actor.Position.ResetZ()] = ph.Victim.Position.ResetZ();
hurt_ranges.Add(DistanceFunctions.GetEuclidDistance3D(ph.Actor.Position, ph.Victim.Position));
continue;
case "player_killed":
PlayerKilled pk = (PlayerKilled)gevent;
edData.Hit_hashtable[pk.Actor.Position.ResetZ()] = pk.Victim.Position.ResetZ();
hurt_ranges.Add(DistanceFunctions.GetEuclidDistance3D(pk.Actor.Position, pk.Victim.Position));
if (pk.Assister != null)
{
edData.DirectAssist_hashtable[pk.Actor.Position.ResetZ()] = pk.Assister.Position.ResetZ();
support_ranges.Add(DistanceFunctions.GetEuclidDistance3D(pk.Actor.Position, pk.Assister.Position));
}
continue;
}
foreach (var player in gevent.getPlayers())
{
var vz = player.Velocity.VZ;
if (vz == 0) //If player is standing thus not experiencing an acceleration on z-achsis -> TRACK POSITION
{
positions.Add(player.Position);
}
else
{
positions.Add(player.Position.ChangeZ(-Player.CSGO_PLAYERMODELL_JUMPHEIGHT)); // Player jumped -> Z-Value is false -> correct with jumpheight
}
}
}
}
}
#endregion
Console.WriteLine("\nRegistered Positions for Sightgraph: " + positions.Count);
Console.WriteLine("\nRegistered Hits: " + edData.Hit_hashtable.Count);
// Generate Map with a constructor
edData.Map = SimpleMapConstructor.CreateMap(mapmeta, positions.ToList());
if (support_ranges.Count != 0)
{
edData.ATTACKRANGE_AVERAGE = hurt_ranges.Average();
}
if (support_ranges.Count != 0)
{
edData.SUPPORTRANGE_AVERAGE = support_ranges.Average();
}
// Generate Hurteventclusters
// Keys of the hashtable are attacker positions, ordering defines a function on how to order the data before performing LEADER
Func <Point3DDataPoint[], Point3DDataPoint[]> ordering = ops => ops.OrderBy(p => p.clusterPoint.X).ThenBy(p => p.clusterPoint.Y).ToArray();
var playerhurtattackerpositions = edData.Hit_hashtable.Keys.Cast <Point3D>();
var wrappedphpositions = new List <Point3DDataPoint>(); // Wrapp Point3D to execute Clustering
playerhurtattackerpositions.ToList().ForEach(p => wrappedphpositions.Add(new Point3DDataPoint(p)));
var leader = new LEADER <Point3DDataPoint>((float)edData.ATTACKRANGE_AVERAGE, wrappedphpositions.ToArray(), ordering);
var attackerclusters = new List <PlayerHurtCluster>();
foreach (var cluster in leader.CreateClusters())
{
var extractedpos = new List <Point3D>();
cluster.ClusterData.ForEach(data => extractedpos.Add(data.clusterPoint));
var attackcluster = new PlayerHurtCluster(extractedpos.ToArray());
attackcluster.CalculateClusterRanges(edData.Hit_hashtable);
attackerclusters.Add(attackcluster);
}
edData.Clusters_PlayerHurt = attackerclusters.ToArray();
}
private void HandleCurrentEvents()
{
foreach (BaseEvent baseEvent in currentTick.Events)
{
switch (baseEvent.Type)
{
case EventType.MatchStarted:
MatchStarted?.Invoke(this, baseEvent);
break;
case EventType.RoundAnnounceMatchStarted:
break;
case EventType.RoundStart:
RoundStart?.Invoke(this, (RoundStartEvent)baseEvent);
break;
case EventType.RoundEnd:
RoundEnd?.Invoke(this, (RoundEndEvent)baseEvent);
break;
case EventType.WinPanelMatch:
WinPanelMatch?.Invoke(this, baseEvent);
break;
case EventType.RoundFinal:
break;
case EventType.LastRoundHalf:
break;
case EventType.RoundOfficiallyEnd:
RoundOfficiallyEnd?.Invoke(this, baseEvent);
break;
case EventType.RoundMVP:
RoundMVP?.Invoke(this, (RoundMVPEvent)baseEvent);
break;
case EventType.FreezetimeEnded:
FreezetimeEnded?.Invoke(this, baseEvent);
break;
case EventType.PlayerKilled:
PlayerKilled?.Invoke(this, (PlayerKilledEvent)baseEvent);
break;
case EventType.PlayerTeam:
PlayerTeam?.Invoke(this, (PlayerTeamEvent)baseEvent);
break;
case EventType.WeaponFired:
WeaponFired?.Invoke(this, (WeaponFiredEvent)baseEvent);
break;
case EventType.SmokeNadeStarted:
SmokeNadeStarted?.Invoke(this, (SmokeNadeStartedEvent)baseEvent);
break;
case EventType.SmokeNadeEnded:
SmokeNadeEnded?.Invoke(this, (SmokeNadeEndedEvent)baseEvent);
break;
case EventType.DecoyNadeStarted:
DecoyNadeStarted?.Invoke(this, (DecoyNadeStartedEvent)baseEvent);
break;
case EventType.DecoyNadeEnded:
DecoyNadeEnded?.Invoke(this, (DecoyNadeEndedEvent)baseEvent);
break;
case EventType.FireNadeStarted:
FireNadeStarted?.Invoke(this, (FireNadeStartedEvent)baseEvent);
break;
case EventType.FireNadeWithOwnerStarted:
FireNadeWithOwnerStarted?.Invoke(this, (FireNadeWithOwnerStartedEvent)baseEvent);
break;
case EventType.FireNadeEnded:
FireNadeEnded?.Invoke(this, (FireNadeEndedEvent)baseEvent);
break;
case EventType.FlashNadeExploded:
FlashNadeExploded?.Invoke(this, (FlashNadeExplodedEvent)baseEvent);
break;
case EventType.ExplosiveNadeExploded:
ExplosiveNadeExploded?.Invoke(this, (ExplosiveNadeExplodedEvent)baseEvent);
break;
case EventType.NadeReachedTarget:
NadeReachedTarget?.Invoke(this, (NadeReachedTargetEvent)baseEvent);
break;
case EventType.BombBeginPlant:
BombBeginPlant?.Invoke(this, (BombBeginPlantEvent)baseEvent);
break;
case EventType.BombAbortPlant:
BombAbortPlant?.Invoke(this, (BombAbortPlantEvent)baseEvent);
break;
case EventType.BombPlanted:
BombPlanted?.Invoke(this, (BombPlantedEvent)baseEvent);
break;
case EventType.BombDefused:
BombDefused?.Invoke(this, (BombDefusedEvent)baseEvent);
break;
case EventType.BombExploded:
BombExploded?.Invoke(this, (BombExplodedEvent)baseEvent);
break;
case EventType.BombBeginDefuse:
BombBeginDefuse?.Invoke(this, (BombBeginDefuseEvent)baseEvent);
break;
case EventType.BombAbortDefuse:
BombAbortDefuse?.Invoke(this, (BombAbortDefuseEvent)baseEvent);
break;
case EventType.PlayerHurt:
PlayerHurt?.Invoke(this, (PlayerHurtEvent)baseEvent);
break;
case EventType.Blind:
Blind?.Invoke(this, (BlindEvent)baseEvent);
break;
case EventType.PlayerBind:
PlayerBind?.Invoke(this, (PlayerBindEvent)baseEvent);
break;
case EventType.PlayerDisconnect:
PlayerDisconnect?.Invoke(this, (PlayerDisconnectEvent)baseEvent);
break;
case EventType.SayText:
SayText?.Invoke(this, (SayTextEvent)baseEvent);
break;
case EventType.SayText2:
SayText2?.Invoke(this, (SayText2Event)baseEvent);
break;
case EventType.PlayerJump:
PlayerJump?.Invoke(this, (PlayerJumpEvent)baseEvent);
break;
case EventType.PlayerFootstep:
PlayerFootstep?.Invoke(this, (PlayerFootstepEvent)baseEvent);
break;
case EventType.OtherDeath:
OtherDeath?.Invoke(this, (OtherDeathEvent)baseEvent);
break;
case EventType.EntitySpawned:
EntitySpawned?.Invoke(this, (EntitySpawnedEvent)baseEvent);
break;
case EventType.EntityRemoved:
EntityRemoved?.Invoke(this, (EntityRemovedEvent)baseEvent);
break;
default:
break;
}
}
}
