void FindClosestTarget()
{
Collider[] hitColliders = Physics.OverlapSphere(transform.position, range);
if (hitColliders.Length > 0)
{
closestDistance = 100f;
foreach (Collider potentialTarget in hitColliders)
{
ObjectStats objectStats = potentialTarget.GetComponent <ObjectStats>();
if (objectStats != null && objectStats.GoblinFaction != goblinFaction)
{
float targetDistance = Vector3.Distance(transform.position, potentialTarget.transform.position);
if (targetDistance < closestDistance)
{
closestDistance = targetDistance;
target = potentialTarget.transform;
}
}
}
}
}
public static void SendStat(User target, int targetId, ObjectStats stat, ObjectType type, object value)
{
BinaryWriter write = GetWriter();
write.Write((byte)5);
write.Write(targetId);
write.Write((byte)stat);
write.Write((byte)type);
switch (type)
{
case ObjectType.INT:
write.Write((int)value);
break;
case ObjectType.UINT:
write.Write((uint)value);
break;
case ObjectType.USHORT:
write.Write((ushort)value);
break;
case ObjectType.BYTE:
write.Write((byte)value);
break;
}
byte[] d = GetBytes();
target.SendData(d);
Clear(stream);
}
private static void ReceiveStat(BinaryReader reader)
{
int id = reader.ReadInt32();
ObjectStats stat = (ObjectStats)reader.ReadByte();
ObjectType type = (ObjectType)reader.ReadByte();
object value;
switch (type)
{
case ObjectType.INT:
value = reader.ReadInt32();
break;
case ObjectType.UINT:
value = reader.ReadUInt32();
break;
case ObjectType.USHORT:
value = reader.ReadUInt16();
break;
case ObjectType.BYTE:
value = reader.ReadByte();
break;
default:
value = 0;
break;
}
UnityMainThreadDispatcher.Instance().Enqueue(() =>
{
GameCore.Stats.SetProperty(id, stat, value);
});
}
void SetToPool()
{
StickingObject stickingObject = Instantiate(prefabStickingObjet, transform.position, Quaternion.identity);
stickingObject.Factory = this;
int materialRandom = Random.Range(0, materials.Length);
Material material = materials[materialRandom];
MeshRenderer mesh = SetMeshChild(stickingObject, material);
float randomSize = Random.Range(.1f, 2f);
ObjectStats stats = new ObjectStats();
stats.SetType((ObjectStats.Type)materialRandom);
stats *= randomSize;
stickingObject.SetObjectStats(stats);
stickingObject.transform.localScale *= randomSize;
stickingObject.transform.SetParent(transform);
stickyQueue.Enqueue(stickingObject);
stickingObject.gameObject.SetActive(false);
}
// Use this for initialization
void Awake()
{
destSetter = GetComponent <Pathfinding.AIDestinationSetter>();
destLerp = GetComponent <Pathfinding.AILerp>();
player = GameObject.Find("Player");
curseController = GameObject.Find("CurseController").GetComponent <CurseController>();
enemyTransform = GetComponent <Transform>();
enemyBoxCollider = GetComponent <BoxCollider2D>();
stats = GetComponent <ObjectStats>();
moveScript = GetComponent <MoveObject>();
moveConf = GetComponent <MoveConfirmation>();
gameCamera = GameObject.Find("Main Camera").GetComponent <CameraController>();
enemyHealthBar = this.transform.Find("ObjectCanvas").transform.Find("EnemyHealthBar").gameObject.GetComponent <RectTransform>();
enemyCanvas = this.transform.Find("ObjectCanvas").gameObject;
healthBarMaxWidth = enemyHealthBar.rect.width;
healthBarCurrWidth = healthBarMaxWidth;
spriteRender = GetComponent <SpriteRenderer>();
stunned = false;
InitializeValues();
destSetter.target = player.transform;
wallLayer = 8;
}
IEnumerator AttackState()
{
agent.destination = transform.position;
if (AttackObject != null)
{
attackStats = AttackObject.GetComponent <ObjectStats>();
InvokeRepeating("Attack", 0f, 1f);
}
else
{
state = State.Travel;
}
while (state == State.Attack)
{
if (AttackObject == null)
{
CancelInvoke("Attack");
state = State.Travel;
}
yield return(0);
}
}
void OnTriggerEnter(Collider col)
{
//not moving object and no object in hands
if (!movingObj && !currentObj)
{
// isObject
if (col.gameObject.layer == 8)
{
ObjectThrow objThrow = col.gameObject.GetComponent <ObjectThrow> ();
if (!objThrow.touchingHand)
{
// change color of object we are touching
ObjectStats objColor = col.gameObject.GetComponent <ObjectStats> ();
objColor.TouchingHands();
// now change values to indicate we are touching it
if (left)
{
objThrow.hand = 1;
}
else
{
objThrow.hand = 2;
}
currentObj = col.gameObject;
col.gameObject.GetComponent <ObjectThrow> ().touchingHand = true;
}
}
}
}
public Vehicle(Model model, ObjectStats.VehicleStats vehicleStats)
: base(model, vehicleStats)
{
rearWheelsCount = vehicleStats.RearWheelCount;
frontWheelsCount = vehicleStats.FrontWheelCount;
doorCount = vehicleStats.DoorCount;
hasTurret = vehicleStats.HasTurret;
waterSourceCount = vehicleStats.WaterSourceCount;
leftDoorAngle = 0;
rightDoorAngle = 0;
leftDoorState = DoorState.Closed;
rightDoorState = DoorState.Closed;
wheelAngle = 0;
wheelState = WheelState.Straight;
NextStep = new Vector2(Position.X,Position.Z);
//TEMP
//leftDoorState = DoorState.Opening;
//rightDoorState = DoorState.Opening;
//wheelState = WheelState.StraightLeft;
//gi = new GameInfo();
}
// Attack function
public void Attack(ObjectStats targetStats)
{
if (attackCooldown <= 0)
{
StartCoroutine(AttackDelay(targetStats, attackDelay));
attackCooldown = 1 / attackSpeed;
}
}
public StaticObject(Model model, ObjectStats.StaticObjectStats staticObjectStats)
: base(model, staticObjectStats)
{
PhysicalTransforms = Matrix.Identity;
OOBoundingBox = new OOBoundingBox(new Vector3(0,0,0), new Vector3(0,0,0));
PositionChanged += OnPositionChanged;
AngleChanged += OnAngleChanged;
}
protected override void Read(ClientProcessor psr, NReader rdr)
{
TickId = rdr.ReadInt32();
TickTime = rdr.ReadInt32();
UpdateStatuses = new ObjectStats[rdr.ReadInt16()];
for (var i = 0; i < UpdateStatuses.Length; i++)
UpdateStatuses[i] = ObjectStats.Read(rdr);
}
// Save stats to player data
public void SaveStats()
{
ObjectStats playerStats = ControllerPlayer.Instance.GetComponent <ObjectStats>();
DataMain.Current.playerData.attack = playerStats.attack;
DataMain.Current.playerData.defence = playerStats.defence;
DataMain.Current.playerData.maxHealth = playerStats.maxHealth;
DataMain.Current.playerData.health = playerStats.currentHealth;
}
// Calculate stats when player level ups
public void CalculateStats()
{
ObjectStats playerStats = ControllerPlayer.Instance.GetComponent <ObjectStats>();
playerStats.attack = new Stats(50 + (int)Mathf.Floor(2 * Mathf.Pow(1.5f, level)));
playerStats.defence = new Stats(10 * level);
playerStats.maxHealth = 150 * level;
playerStats.currentHealth = playerStats.maxHealth;
}
internal void ImportStats(ObjectStats stats)
{
Id = stats.Id;
Position = stats.Position;
foreach (var i in stats.Stats)
{
ImportStats(i.Key, i.Value);
}
}
protected override void Read(NReader rdr)
{
TickId = rdr.ReadInt32();
TickTime = rdr.ReadInt32();
UpdateStatuses = new ObjectStats[rdr.ReadInt16()];
for (int i = 0; i < UpdateStatuses.Length; i++)
UpdateStatuses[i] = ObjectStats.Read(rdr);
}
// FUNCTION //
// Initialize player UI with information
private void Start()
{
playerStats = ControllerPlayer.Instance.GetComponent <ObjectStats>();
// Prefill UI
playerName.text = DataMain.Current.playerData.playerName;
playerLevel.text = "Lv: " + DataMain.Current.playerData.level;
expBar.fillAmount = DataMain.Current.playerData.expRatio;
hpBar.fillAmount = (float)playerStats.currentHealth / (float)playerStats.maxHealth;
}
void OnTriggerEnter(Collider other)
{
ObjectStats enemyStats = other.GetComponent <ObjectStats>();
if (enemyStats != null && objectStats.GoblinFaction != enemyStats.GoblinFaction)
{
unitController.AttackObject = other.gameObject;
unitController.state = UnitController.State.Attack;
}
}
void OnTriggerEnter(Collider other)
{
ObjectStats objectStats = other.GetComponent <ObjectStats>();
if (objectStats != null && objectStats.GoblinFaction != goblinFaction)
{
objectStats.Damage(damage);
Destroy(gameObject);
}
}
internal static void AddStat(ObjectStats stat)
{
BinaryWriter write = GetWriter();
write.Write((byte)2);
write.Write((byte)stat);
byte[] d = GetBytes();
WebSocketDemo.Instance.SendData(d);
Clear(stream);
}
// FUNCTIONS //
// Initialization
private void Awake()
{
Instance = this;
playerAgent = GetComponent <NavMeshAgent>();
cameraDirection = Camera.main.transform;
currentTransform = GetComponent <Transform>();
animator = GetComponent <Animator>();
playerStats = GetComponent <ObjectStats>();
}
protected override void Read(ClientProcessor psr, NReader rdr)
{
TickId = rdr.ReadInt32();
TickTime = rdr.ReadInt32();
UpdateStatuses = new ObjectStats[rdr.ReadInt16()];
for (var i = 0; i < UpdateStatuses.Length; i++)
{
UpdateStatuses[i] = ObjectStats.Read(rdr);
}
}
public void ImportStats(ObjectStats stat)
{
Id = stat.Id;
(this is Enemy ? Owner.EnemiesCollision : Owner.PlayersCollision)
.Move(this, stat.Position.X, stat.Position.Y);
X = stat.Position.X;
Y = stat.Position.Y;
foreach (var i in stat.Stats)
{
ImportStats(i.Key, i.Value);
}
}
public void Awake()
{
stamina *= dexterity;
maxHealth *= constitution;
maxMana *= wisdom;
curStamina = maxStamina;
curMana = maxMana;
secondaryHealth = curHealth;
objects = GameObject.FindGameObjectWithTag("PainBox");
objectstats = objects.GetComponent <ObjectStats>();
}
public PlayerStats(ObjectStats objStats)
{
name = objStats.name;
active = objStats.active;
posX = objStats.posX;
posY = objStats.posY;
posZ = objStats.posZ;
rotX = objStats.rotX;
rotY = objStats.rotY;
rotZ = objStats.rotZ;
rotW = objStats.rotW;
}
private void OnTriggerExit2D(Collider2D collision)
{
if (collision.isTrigger)
{
return;
}
ObjectStats other = collision.GetComponent <ObjectStats>();
if (other != null)
{
objects.Remove(other);
}
}
public void RecrusiveCalculateStats(ObjectStats playerStats)
{
playerStats += objectStats;
foreach (StickingObject stickingChild in stickingObjectChilds)
{
if (stickingChild == this)
{
Debug.LogError("HUGE MISTAKE");
}
stickingChild.RecrusiveCalculateStats(playerStats);
}
}
private void StatChanged(ObjectStats stat, object value)
{
if (value == null)
{
return;
}
switch (stat)
{
case ObjectStats.GOLD:
goldText.text = value.ToString();
break;
}
}
public ShipConsumableCard(uint cardGUID, CardView cardView, ushort consumableType, ObjectStats itemBuffMultiply, ObjectStats itemBuffAdd, byte tier, AugmentActionType action, bool isAugment, bool autoConsume, bool trashable, uint buyCount, ConsumableAttribute[] sortingAttributes, ConsumableEffectType effectType)
: base(cardGUID, cardView)
{
ConsumableType = consumableType;
ItemBuffMultiply = itemBuffMultiply;
ItemBuffAdd = itemBuffAdd;
Tier = tier;
Action = action;
IsAugment = isAugment;
AutoConsume = autoConsume;
Trashable = trashable;
this.buyCount = buyCount;
this.sortingAttributes = sortingAttributes;
this.effectType = effectType;
}
public void InitializeValues()
{
stats = GetComponent <ObjectStats>();
spriteRender = GetComponent <SpriteRenderer>();
moveScript = GetComponent <PlayerMovement>();
curses = new List <string>();
stats.SetMaxHealth(Constants.PLAYER_STARTING_HEALTH);
stats.SetHealth(stats.GetMaxHealth());
stats.SetDamage(Constants.PLAYER_STARTING_DAMAGE);
stats.currFloor = 1;
stats.sightRange = 7;
stats.goldCount = 0;
}
// Use this for initialization
void Start()
{
ObjectStats objstat = new ObjectStats(gameObject.GetComponent <Renderer>());
Stats = objstat;
if (ChangeByTag)
{
foreach (GameObject otherObject in GameObject.FindGameObjectsWithTag(gameObject.tag))
{
if (!otherObject.GetComponent <MaterialChanger>())
{
otherObject.AddComponent(this);
}
}
}
}
public Building(Model model, ObjectStats.BuildingStats buildingStats)
: base(model, buildingStats)
{
PhysicalTransforms = Matrix.Identity;
Vector3 min = new Vector3(float.MaxValue, float.MaxValue, float.MaxValue);
Vector3 max = new Vector3(float.MinValue, float.MinValue, float.MinValue);
for (int i = 0; i < Model.Meshes.Count; ++i)
{
BoundingBox bb;
BoundingBoxTools.CalculateBoundingBox(Model.Meshes[i], out bb);
if (min.X > bb.Min.X)
{
min.X = bb.Min.X;
}
if (min.Y > bb.Min.Y)
{
min.Y = bb.Min.Y;
}
if (min.Z > bb.Min.Z)
{
min.Z = bb.Min.Z;
}
if (max.X < bb.Max.X)
{
max.X = bb.Max.X;
}
if (max.Y < bb.Max.Y)
{
max.Y = bb.Max.Y;
}
if (max.Z < bb.Max.Z)
{
max.Z = bb.Max.Z;
}
}
BoundingBox = new BoundingBox(min, max);
OOBoundingBox = new OOBoundingBox(BoundingBox, scale);
Length = scale * (BoundingBox.Max.Z - BoundingBox.Min.Z);
Width = scale * (BoundingBox.Max.Y - BoundingBox.Min.Y);
Height = scale * (BoundingBox.Max.X - BoundingBox.Min.X);
PhysicalTransforms = Matrix.Identity;
PositionChanged += OnPositionChanged;
AngleChanged += OnAngleChanged;
}
// Returns a PlayerStats object containing the extra stats that the player has.
// The regular ObjectStats should be in 'stats' already.
private static PlayerStats SavePlayerStats(ObjectStats stats, GameObject player, string scene)
{
PlayerStats plStats = new PlayerStats(stats);
PlayerAbilityManager abilityManager = player.GetComponent <PlayerAbilityManager>();
if (abilityManager != null)
{
plStats.enabledAbilities = abilityManager.getEnabledAbilities();
}
PlayerHealth plHealth = player.GetComponent <PlayerHealth>();
if (plHealth != null)
{
plStats.health = plHealth.getHealth();
}
plStats.sceneName = scene;
return(plStats);
}
private void UpdateStats(ref ObjectStats stats)
{
int count = 0;
foreach (var i in stats.Stats)
{
if (i.Item1 >= StatsType.Inventory0 && i.Item1 <= StatsType.Inventory8 &&
(int)i.Item2 > 0)
{
count++;
}
}
string name = string.Format("{0}/8", count);
stats.Stats = stats.Stats.Concat(new[]
{
Tuple.Create(StatsType.Name, (object)name)
}).ToArray();
}
// FUNCTIONS //
// Use this for initialization
void Start()
{
// Get navmesh objects
enemyAgent = GetComponent <NavMeshAgent>();
enemyObstacle = GetComponent <NavMeshObstacle>();
// Get animator
attackAnimator = attackEffect.GetComponent <Animator>();
enemyAnimator = enemyEffect.GetComponent <Animator>();
// Get enemy and player's stats and combat controller
enemyCombat = GetComponent <ControllerCombat>();
playerCombat = ControllerPlayer.Instance.GetComponent <ControllerCombat>();
enemyStats = GetComponent <ObjectStats>();
playerStats = ControllerPlayer.Instance.GetComponent <ObjectStats>();
// Get player transform
playerTransform = ControllerPlayer.Instance.transform;
}
// Use this for initialization
public static void Init () {
// % No items, % One items, % Two items, % Three items, % Four items
GeneratedItemsPercent = new int[5]{1, 1, 1, 1, 1 };
GameObjects = new ObjectStats[12];
GameObjects [0] = new ObjectStats ("FoodBanana", 0, QType.Avoidable, Direction.None, 20, Stats.Load("BananaPrefab"));
GameObjects [1] = new ObjectStats ("FoodPineapple", 1, QType.Avoidable, Direction.None, 20, Stats.Load("PineapplePrefab"));
GameObjects [2] = new ObjectStats ("FoodBigPretzel", 2, QType.Avoidable, Direction.None, 20, Stats.Load("PretzelPrefab"));
GameObjects [3] = new ObjectStats ("FoodPizza", 3, QType.Avoidable, Direction.None, 20, Stats.Load("PizzaPrefab"));
GameObjects [4] = new ObjectStats ("InsulinOne", 4, QType.Avoidable, Direction.None, 20, Stats.Load("InsulinOne"));
GameObjects [5] = new ObjectStats ("InsulinThree", 5, QType.Avoidable, Direction.None, 20, Stats.Load("InsulinThree"));
GameObjects [6] = new ObjectStats ("InsulinFive", 6, QType.Avoidable, Direction.None, 20, Stats.Load("InsulinFive"));
GameObjects [7] = new ObjectStats ("InsulinSeven", 7, QType.Avoidable, Direction.None, 20, Stats.Load("InsulinSeven"));
GameObjects [8] = new ObjectStats ("BlockingWall", 8, QType.Blocking, Direction.None, 20, Stats.Load("WallRegularPrefab"));
GameObjects [9] = new ObjectStats ("BlockingUDWall", 9, QType.Moving, Direction.UpDown, 0, null);
GameObjects [10] = new ObjectStats ("BlockingLRWall", 10, QType.Moving, Direction.LeftRight, 0, null);
GameObjects [11] = new ObjectStats ("Fan", 11, QType.FullRoom, Direction.None, 5, Stats.Load("FanPrefab"));
for (int i = 0; i < GameObjects.Length; i++) {
KeyMap [GameObjects [i].Name] = i;
}
}
//Tags iself and generates a reference to its stats.
public override void Start()
{
//rigidbody.constraints = RigidbodyConstraints.FreezeRotationX | RigidbodyConstraints.FreezeRotationZ;
gameObject.tag = "netObject";
netObject = this;
objectStats = gameObject.GetComponent<ObjectStats>();
gameObject.layer = LayerMask.NameToLayer("netObject");
base.Start();
}
public Infantry(Model model, ObjectStats.InfantryStats infantryStats)
: base(model, infantryStats)
{
}
public Civilian(Model model, ObjectStats.CivilianStats civilianStats)
: base(model, civilianStats)
{
PositionChanged += OnPositionChanged;
AngleChanged += OnAngleChanged;
}
public void ImportStats(ObjectStats stat)
{
Id = stat.Id;
(this is Enemy ? Owner.EnemiesCollision : Owner.PlayersCollision)
.Move(this, stat.Position.X, stat.Position.Y);
X = stat.Position.X;
Y = stat.Position.Y;
foreach (var i in stat.Stats)
ImportStats(i.Key, i.Value);
UpdateCount++;
}
