public void OnRoll(NetworkMessage msg)
{
if (msg.conn.connectionId == battle.currentTurn && battle.rollsLeft > 0)
{
PlayerPawn pawn = battle.GetCurrentPawn() as PlayerPawn;
int[] rolls = new int[battle.rolls.Length];
double[] weights = new double[pawn.Affinities.Length];
for (int i = 0; i < weights.Length; i++)
{
weights[i] = pawn.GetAffinity(i);
}
for (int i = 0; i < rolls.Length; i++)
{
if (battle.locks[i])
{
rolls[i] = battle.rolls[i].GetId();
}
else
{
rolls[i] = Element.All[REX.Weighted(weights)].GetId();
}
battle.rolls[i] = Element.All[rolls[i]];
}
battle.rollsLeft -= 1;
NetworkServer.SendToAll(GameMsg.Roll, new GameMsg.MsgIntegerArray()
{
array = rolls
});
}
}
void OnTriggerEnter2D(Collider2D collider)
{
PlayerPawn playerPawn = collider.GetComponent(typeof(PlayerPawn)) as PlayerPawn;
PlayerAttackDamageLeft PL = collider.GetComponent(typeof(PlayerAttackDamageLeft)) as PlayerAttackDamageLeft;
PlayerAttackDamage PR = collider.GetComponent(typeof(PlayerAttackDamage)) as PlayerAttackDamage;
if (playerPawn != null)
{
playerPawn.Damage(gameObject.transform.right);
if (!penetrate)
{
if (explosive)
{
GameObject clone;
clone = Instantiate(boom, gameObject.transform.position, gameObject.transform.rotation);
}
Destroy(gameObject);
}
}
if (PL != null || PR != null)
{
if (destructable)
{
Destroy(gameObject);
if (explosive)
{
GameObject clone;
clone = Instantiate(boom, gameObject.transform.position, gameObject.transform.rotation);
}
}
}
}
void OnTriggerEnter2D(Collider2D collider)
{
PlayerPawn playerPawn = collider.GetComponent(typeof(PlayerPawn)) as PlayerPawn;
PlayerAttackDamageLeft PL = collider.GetComponent(typeof(PlayerAttackDamageLeft)) as PlayerAttackDamageLeft;
PlayerAttackDamage PR = collider.GetComponent(typeof(PlayerAttackDamage)) as PlayerAttackDamage;
if (playerPawn != null)
{
hit = true;
if (damaging)
{
playerPawn.Damage(baseEnemy.gameObject.transform.right);
}
}
else if (PL != null)
{
}
else if (PR != null)
{
}
else
{
bash = true;
}
}
internal void UpdatePlayerDebugOverlay()
{
PlayerPawn Player = GameInfo.PlayerCtrl.PlayerPawn;
if (Player == null || Player.RB == null)
{
return;
}
int numberOfRows = 6;
GUI.BeginGroup(new Rect(25, 50, DebugVarables.GROUP_WIDTH, numberOfRows * DebugVarables.LINE_HEIGHT));
GUI.Label(new Rect(0, 0, DebugVarables.GROUP_WIDTH, DebugVarables.LINE_HEIGHT), "Player Controls");
//sliders
Player.RB.mass = m_Player_Mass = DebugGui.CreateSliderRow(1, "Mass", Player_Mass, 0.1f, 10);
Player.RB.drag = m_Player_Drag = DebugGui.CreateSliderRow(2, "Drag", Player_Drag, 0, 10);
Player.TurningRate = m_Player_TurningRate = DebugGui.CreateSliderRow(3, "TurningRate", Player_TurningRate, 0, 20);
Player.MaxSpeed = m_Player_MaxSpeed = DebugGui.CreateSliderRow(4, "MaxSpeed", Player_MaxSpeed, 0, 50);
Player.ThrustAmt = m_Player_ThrustAmt = DebugGui.CreateSliderRow(5, "ThrustAmt", Player_ThrustAmt, 0, 500);
GUI.EndGroup();
// Player.RB.mass = m_Player_Mass;
// Player.RB.drag = m_Player_Drag;
// Player.TurningRate = m_Player_TurningRate;
// Player.MaxSpeed = m_Player_MaxSpeed;
// Player.ThrustAmt = m_Player_ThrustAmt;
}
// Start is called before the first frame update
void Start()
{
// Access the Player Pawn script
playerPawn = GetComponent <PlayerPawn>();
pawn = playerPawn;
moveDirection = new Vector3(Input.GetAxis("Horizontal"), 0f, Input.GetAxis("Vertical"));
}
private PlayerPawn CreatePawn(int connectionId)
{
PlayerPawn pawn = new PlayerPawn(this, Vector2.zero, connectionId);
pawn.OnDeath += OnPawnDeath;
return(pawn);
}
public bool IsPlayerAlive(int sessionId)
{
PlayerPawn pawn = null;
m_players.TryGetValue(sessionId, out pawn);
return(pawn != null && pawn.IsAlive);
}
/// <summary>
/// Function to spawn PlayerPawn. Based on predefined Spawnpoints in the Scene
/// </summary>
/// <param name="playerController"></param>
void SpawnPlayerPlawn(PlayerControllerBase playerController)
{
if (gameState == GameState.GameEnded)
{
return;
}
List <SpawnPoint> availableSpawnpoints = new List <SpawnPoint>();
foreach (SpawnPoint spawnPoint in spawnPoints)
{
if (!spawnPoint.isOccupied)
{
availableSpawnpoints.Add(spawnPoint);
}
}
if (availableSpawnpoints.Count == 0)
{
Debug.LogError("No available spawnpoint found, make sure each level has more spawnpoints than max player count");
return;
}
SpawnPoint randomSpawnpoint = availableSpawnpoints[Random.Range(0, availableSpawnpoints.Count)];
PlayerPawn spawnedPawn = randomSpawnpoint.SpawnPawn(playerPawnPrefab);
playerController.SetPawn(spawnedPawn);
}
// Use this for initialization
void Start()
{
// initialize variables
playerPawn = (PlayerPawn)pawn;
rb2d = pawn.GetComponent <Rigidbody2D>();
sr = pawn.GetComponent <SpriteRenderer>();
}
//Future implementation: target is marked as target. Animation happens, and when OnTriggerEnter() intersects with the collider of target, that is when target takes damage.
protected override void Use(Pawn user)
{
if (_anim)
{
// OH GOD PLEASE CHANGE THIS
Vector3 vel = user.GetComponent <Rigidbody>().velocity;
_anim.SetFloat("Speed", new Vector2(vel.x, vel.z).magnitude);
}
if (!(user is PlayerPawn))
{
return;
}
PlayerPawn playerUser = user as PlayerPawn;
GameObject target = null;
if (playerUser.Raycaster.RaycastInfo.DidHit)
{
target = playerUser.Raycaster.RaycastInfo.GetHitGameObjectAtRange(reach);
}
DoAttack(target, user);
}
public override PlayerPawn Create(LobbyClientHandler.LobbyPlayer lobbyPlayer)
{
PlayerPawn player = new PlayerPawn(lobbyPlayer.charName, maxHp);
player.SetId(lobbyPlayer.id);
int[] affinityCounts = new int[Element.Count];
Spell[] spellsToLearn = REX.Choice(DB.BuyableSpells, 4);
for (int i = 0; i < spellsToLearn.Length; i++)
{
ElementDisplay[] d = spellsToLearn[i].GetElementDisplays(RollContext.Null);
for (int j = 0; j < d.Length; j++)
{
affinityCounts[d[j].element.GetId()]++;
}
}
foreach (Spell spell in spellsToLearn)
{
player.AddSpell(spell);
}
for (int i = 0; i < Element.Count; i++)
{
if (affinityCounts[i] > 0)
{
player.Affinities[i].AddModifier(new AttributeModifier(GetName(), AttributeModifier.Operation.AddBase, affinityCounts[i]));
}
}
return(player);
}
public void PlayerPawnDontAddWhenMissingChannelTest()
{
var state = new FortPlayerState()
{
PlayerID = 1,
UniqueId = "abc-123",
BotUniqueId = "",
bIsABot = false,
TeamIndex = 1,
HeroType = new ItemDefinition()
{
Name = "bandolier"
}
};
builder.UpdatePlayerState(1, state);
var pawn = new PlayerPawn()
{
PlayerState = 100,
Pickaxe = new ItemDefinition()
{
Name = "raiders revenge"
}
};
builder.UpdatePlayerPawn(2, pawn);
builder.Build(replay);
Assert.Null(replay.PlayerData.First().Cosmetics.Pickaxe);
}
protected virtual void OnCollisionEnter2D(Collision2D otherObject)
{
PlayerPawn player = otherObject.gameObject.GetComponent <PlayerPawn>();
if (!arrowStoped)
{
if (player)
{
bool isPlayerDead = player.OnShot(damage);
Logger.Log(player.ToString() + isPlayerDead, this, LogLevel.Verbose);
if (!isPlayerDead)
{
PickupArrow(player);
}
}
StopArrow();
rb.Sleep();
}
else
{
if (player)
{
PickupArrow(player);
}
}
}
private PlayerPawn TryGetPawn(int id)
{
PlayerPawn pawn = null;
m_players.TryGetValue(id, out pawn);
return(pawn);
}
public void ShootLaser(SimpleRay2D ray, PlayerPawn owner)
{
List <PlayerPawn> playersHit = CastRay(ray);
Network.Log("Laser hits " + playersHit.Count + " players.");
float laserPower = owner.GetLaserDamage();
float powerAccumulator = 0.0f;
for (int i = 0; i < playersHit.Count; ++i)
{
if (playersHit[i] == owner)
{
continue;
}
powerAccumulator += playersHit[i].ReceiveDamage(laserPower);
}
owner.AddPower(powerAccumulator);
ShotEvent se = new ShotEvent();
se.m_direction = ray.direction;
se.m_point = owner.Position;
se.m_who = owner.Id;
se.m_reliableEventId = Network.Server.GetNewReliableEventId();
foreach (int id in m_players.Keys)
{
Network.Server.Send(se, id, true);
}
}
// Use this for initialization
void Start()
{
enemyPawn = (AIPawn)pawn;
playerPawn = (PlayerPawn)GetComponent <PlayerController>().pawn;
aiTransform = enemyPawn.GetComponent <Transform>();
target = playerPawn.GetComponent <Transform>();
}
void OnTriggerEnter2D(Collider2D collider)
{
PlayerPawn playerPawn = collider.GetComponent(typeof(PlayerPawn)) as PlayerPawn;
if (playerPawn != null)
{
}
}
public PlayerPawn AddPlayer(int sessionId)
{
PlayerPawn pawn = CreatePawn(sessionId);
m_players[sessionId] = pawn;
Console.WriteLine("Player pawn added with id: " + sessionId);
return(pawn);
}
public void OnOpenVendor(NetworkMessage msg)
{
PlayerPawn pawn = msg.ReadMessage <GameMsg.MsgPawn>().pawn as PlayerPawn;
VendorScreen screen = new VendorScreen(game, RB.DisplaySize, pawn);
game.OpenClientHandler(new VendorClientHandler(game, pawn, screen));
game.OpenScreen(screen);
}
public VendorScreen(Game game, Vector2i size, PlayerPawn pawn) : base(game, size)
{
this.pawn = pawn;
buyButtons = new VendorButton[0];
sellButtons = new VendorButton[0];
UpdateSell(pawn.GetKnownSpellIds());
vendorText.SetText(vendorText.GetText() + "\n\nYou can currently know @FFFFFF" + pawn.SpellSlotCount.GetValue() + "@- spells.");
}
public void EquipGun(GameObject weaponType)
{
// play the designated audioclip
AudioSource.PlayClipAtPoint(audio, transform.position, vol);
// Create a weapon
if (owner.tag == "Player")
{
playerPawn = owner.GetComponent <PlayerPawn>();
if (playerPawn.weaponEquipped == true)
{
// do nothing if the player already has a weapon
return;
}
GameObject gun = Instantiate(weaponType, playerPawn.attachPoint.position, Quaternion.identity) as GameObject;
if (gun.tag == "Rifle")
{
weapon = gun.GetComponent <Rifle>();
}
else if (gun.tag == "RocketLauncher")
{
weapon = gun.GetComponent <RocketLauncher>();
}
// Make the gun a child of the owner
gun.transform.SetParent(playerPawn.attachPoint, false);
gun.transform.localPosition = weaponType.transform.localPosition;
gun.transform.localRotation = weaponType.transform.localRotation;
// Let Player Pawn know the player is using a weapon
playerPawn.weaponEquipped = true;
playerPawn.gun = gun;
playerPawn.weapon = weapon;
}
else if (owner.tag == "Enemy")
{
if (enemyPawn.weaponEquipped == true)
{
// do nothing if the enemy already has a weapon
return;
}
enemyPawn = owner.GetComponent <EnemyPawn>();
GameObject gun = Instantiate(weaponType, enemyPawn.attachPoint.position, Quaternion.identity) as GameObject;
if (gun.tag == "Rifle")
{
weapon = gun.GetComponent <Rifle>();
}
else if (gun.tag == "RocketLauncher")
{
weapon = gun.GetComponent <RocketLauncher>();
}
// Make the gun a child of the owner
gun.transform.SetParent(enemyPawn.attachPoint, false);
gun.transform.localPosition = weaponType.transform.localPosition;
gun.transform.localRotation = weaponType.transform.localRotation;
// Let Player Pawn know the player is using a weapon
enemyPawn.weaponEquipped = true;
enemyPawn.gun = gun;
enemyPawn.weapon = weapon;
}
}
public void PawnDeath()
{
Debug.Log("[PlayerController] Destroying PlayerGameObject");
Destroy(PlayerGameObject);
PlayerPawn = null;
m_PlayerGameObject = null;
onPlayerDeath();
}
// Start is called before the first frame update
public override void Start()
{
base.Start(); //Calling the parent start function
if (controller == null)
{
controller = this;
}
player = FindObjectOfType <PlayerPawn>();
}
protected virtual void PickupArrow(PlayerPawn player)
{
player.GetComponent <PlayerShooting>().AddArrows(1);
GetComponent <BoxCollider2D>().enabled = false;
GetComponent <SpriteRenderer>().enabled = false;
GetComponentInChildren <LightScript>().FadeAway(fadeTime);
Destroy(gameObject, fadeTime);
}
public virtual void Shoot(float speed, PlayerPawn owner)
{
this.owner = owner;
Physics2D.IgnoreCollision(owner.GetComponent <Collider2D>(), GetComponent <Collider2D>());
GetComponent <Collider2D>().enabled = true;
Vector2 direction = transform.rotation * Vector2.right;
rb.AddForce(direction * speed);
}
/// <summary>Stores the pawn as holding pawn</summary>
public void SetHoldingPawn(PlayerPawn pawn)
{
pawnHolding = pawn;
boxCollider.size = colliderSize * 0.5f;
foreach (Material mat in materials)
{
mat.SetColor("_EmissionColor", defaultEmissionColor);
}
}
public override void OnEquipped(Pawn pawn)
{
PlayerPawn player = pawn as PlayerPawn;
if (player != null)
{
player.EndOfBattleRestoration.AddModifier(new AttributeModifier(GetName(), AttributeModifier.Operation.MultiplyTotal, 2));
}
}
void OnTriggerExit2D(Collider2D collider)
{
PlayerPawn playerPawn = collider.GetComponent(typeof(PlayerPawn)) as PlayerPawn;
if (playerPawn != null)
{
sighted = false;
}
}
public override void OnUnequipped(Pawn pawn)
{
PlayerPawn player = pawn as PlayerPawn;
if (player != null)
{
player.EndOfBattleRestoration.RemoveModifier(GetName());
}
}
void Start()
{
mManagerInstance = this.GetComponent <GameMenuManager>();
gAreaAnimator = this.GetComponent <GameAreaAnimator>();
playerPawn = playerObject.GetComponent <PlayerPawn>();
originalPlayerPosition = playerPawn.transform.position;
// Second value is arbitrary and decided based on game feel.
gAreaAnimator.SetReferences(groundObject, difficultyRamp * 4);
}
// Use this for initialization
void Start ()
{
playerPawn = player.GetComponent<PlayerPawn>();
InvokeRepeating("IncrementTimer", 0.0f, 1.0f);
}
void Start ()
{
player = GM.GetComponent<GameManager>().player.GetComponent<PlayerPawn>();
}
