private void userControl11_LayerDropped(LegendDroppedEventArgs e)
{
bool isMoved = LayerLogic.MoveLayer(e.destinationNode, e.movingNode, aggregator);
if (!isMoved)
{
MessageBox.Show("Failed to move");
}
}
private void mapWinControl1_FileDropped(object sender, MapWinControl._DMapEvents_FileDroppedEvent e)
{
int layerHandle = LayerLogic.AddLayer(e.filename, ZoomMode.ZoomToLayer, true, aggregator);
//if(layerHandle != -1)
//{
// Layer layer = new Layer();
// layer.Handle = layerHandle;
// layer.Filename = Path.GetFileName(e.filename);
// aggregator.AddLayer(layer);
//}
}
public Vector3 offset = Vector3.zero; // This can be set in inspector
public bool IsPlacementValid()
{
// Checks for collision:
if (GetComponent <BoxCollider> ())
{
Collider[] collidersHit = Physics.OverlapBox(transform.TransformPoint(GetComponent <BoxCollider> ().center),
new Vector3(GetComponent <BoxCollider> ().size.x *transform.lossyScale.x / 2,
GetComponent <BoxCollider> ().size.y *transform.lossyScale.y / 2,
GetComponent <BoxCollider> ().size.z *transform.lossyScale.z / 2), transform.rotation, LayerLogic.PlacePlayerMadeCollision());
if (collidersHit.Length > 0)
{
// We need to go and find which PlayerMadeObject it collided with, because Physics.CheckBox doesn't give us that information, and Physics.BoxCast doesn't work for this.
foreach (Collider c in collidersHit)
{
if (c.gameObject.layer == 19) // Must be AntiPlacement layer
{
c.GetComponent <ShowInvalidBoundingBoxPMO> ().updateBeingShown();
}
}
return(false);
}
if (canPlaceOn == canPlaceOnWalls || canPlaceOn == canPlaceAnywhere)
{
int mult = 1;
if (canPlaceOn == canPlaceAnywhere)
{
mult = -1;
}
Vector3 center = GetComponent <BoxCollider> ().center + new Vector3(0, 0, GetComponent <BoxCollider> ().size.z / 2) * mult;
float widthRad = GetComponent <BoxCollider> ().size.x / 2;
float heightRad = GetComponent <BoxCollider> ().size.y / 2;
for (float nX = -0.8f; nX <= 0.8f; nX += 0.4f)
{
for (float nY = -0.8f; nY <= 0.8f; nY += 0.4f)
{
if ((nX != 0 || nY != 0) && !checkTypeWall(center, widthRad, heightRad, mult, nX, nY))
{
return(false);
}
}
}
return(true);
}
else
{
Vector3 center = GetComponent <BoxCollider> ().center - new Vector3(0, GetComponent <BoxCollider> ().size.y / 2, 0);
float widthRad = GetComponent <BoxCollider> ().size.x / 3;
float heightRad = GetComponent <BoxCollider> ().size.z / 3;
for (float nX = -0.8f; nX <= 0.8f; nX += 0.4f)
{
for (float nY = -0.8f; nY <= 0.8f; nY += 0.4f)
{
if ((nX != 0 || nY != 0) && !checkTypeFloor(center, widthRad, heightRad, nX, nY))
{
return(false);
}
}
}
return(true);
}
}
return(true);
}
private void userControl11_Checked(CheckedEventArgs e)
{
LayerLogic.ChangeVisibility(aggregator, e.ItemName, e.Visible, e.Handle, this.mapWinControl1);
}
public override void ServerSyncFixedUpdate()
{
base.ServerSyncFixedUpdate();
if (exists)
{
// Detect collisions:
RaycastHit hitInfo;
Vector3 forward = Vector3.Normalize(lastVelocity);
// Assumed to be sphere scaling factor:
if (Physics.SphereCast(new Ray(transform.position, forward), transform.localScale.x, out hitInfo,
Vector3.Distance(Vector3.zero, lastVelocity * Time.fixedDeltaTime), LayerLogic.ProjectileCollision(ignoreTeam)))
{
if (hitInfo.collider.CompareTag("Mirror"))
{
Vector3 mirrorForward = hitInfo.transform.Find("ReflectPlane").up;
// Sets initial velocity / initial position / accordingly. (Also resets tickSpawnedAt)
initialVelocity = Vector3.Reflect(lastVelocity, mirrorForward);
lastVelocity = initialVelocity;
// Rather than doing a proper reflection, the reflection that is done is as if the projectile goes through the mirror- this will speed up the projectile though.
// This could be done better, of course, to avoid this speed up.
Plane plane = new Plane(mirrorForward, hitInfo.transform.Find("ReflectPlane").position);
float enter;
plane.Raycast(new Ray(transform.position, forward), out enter);
initialPosition = transform.position + Vector3.ProjectOnPlane(forward * enter, mirrorForward) * 2;
transform.position = initialPosition;
tickSpawnedAt = ServerState.tickNumber;
if (ignoreTeam == hitInfo.transform.GetComponent <MirrorLogic> ().team)
{
expDmg *= 2; // Double damage
}
}
else
{
BlowUp(hitInfo.transform);
}
}
}
// Still move if exists = false (?)
transform.position = initialPosition + initialVelocity * getLifeTimeServer();
transform.forward = Vector3.Normalize(initialVelocity);
}
public override void ServerSyncFixedUpdate()
{
base.ServerSyncFixedUpdate();
// It seems like "OperationAddSyncState" shouldn't be done in InitStart..
if (!firstUpdateDone)
{
firstUpdateDone = true;
if (GameManager.GetPlayer(playerOwner).playerObject != null)
{
// trip wire won't go up or down, it'll stay straight:
Vector3 pos = GameManager.GetPlayer(playerOwner).playerObject.transform.position;
//pos.y = transform.position.y - 1.1f;
RaycastHit hit;
if (Physics.Raycast(transform.position + Vector3.down * 1.5f, Vector3.Normalize(pos - (transform.position + Vector3.down * 1.5f)), out hit, 12f, LayerLogic.WorldColliders()))
{
// hmm..
}
GameObject obj = (GameObject)Instantiate(arrowTrigger, pos + Vector3.down, Quaternion.identity);
obj.GetComponent <PlayerMade> ().playerOwner = playerOwner;
OperationNetwork.OperationAddSyncState(obj);
}
}
GeneralUpdate();
}
void Update()
{
bool renderHealthBar = false;
if (!GetComponent <PlayerMove>() || !GetComponent <PlayerMove>().thisIsMine)
{
if (Player.thisPlayer != null && Player.thisPlayer.playerObject != null)
{
if (Player.thisPlayer.playerObject.GetComponent <ClassControl>().classNum == 4 && Player.thisPlayer.team == team)
{
renderHealthBar = true;
if (!this.renderHealthBar)
{
this.renderHealthBar = true;
healthBar.GetComponent <Renderer>().enabled = true;
healthBar.parent.GetComponent <Renderer>().enabled = true;
}
// Display health bar:
if (healthBar != null)
{
healthBar.localScale = new Vector3(1.01f * health / maxHealth, 1.01f, 1.01f);
healthBar.localPosition = new Vector3(-0.505f + 0.505f * health / maxHealth, 0, -0.01f);
healthBar.parent.rotation = Quaternion.LookRotation(healthBar.parent.position - Player.thisPlayer.playerCamera.transform.position);
}
}
}
}
else
{
// Kill bind
if (Input.GetKeyDown(KeyCode.K))
{
GetComponent <OperationView> ().RPC("KillSelf", OperationNetwork.ToServer);
}
// SOUND QUEUES:
timeSinceLastVoiceQueue += Time.deltaTime;
if (timeSinceLastVoiceQueue > 0.7f)
{
// Call for medic:
if (Input.GetKeyDown(KeyCode.Z) || Input.GetKeyDown(KeyCode.X))
{
VoiceLine((byte)Random.Range(0, 2), 255, true); // Full volume for now..
timeSinceLastVoiceQueue = 0f;
}
}
while (damageIndicatorsTime.Count > 0 && Time.time - damageIndicatorsTime[0] > 2.0f)
{
Destroy(damageIndicators[0]);
damageIndicators.RemoveAt(0);
damageIndicatorsFrom.RemoveAt(0);
damageIndicatorsTime.RemoveAt(0);
}
for (int i = 0; i < damageIndicators.Count; i++)
{
Vector3 loc = Vector3.ProjectOnPlane(GetComponent <PlayerMove>().mainCamera.transform.forward, damageIndicatorsFrom[i] - GetComponent <PlayerMove>().mainCamera.transform.position);
Quaternion rotation = Quaternion.LookRotation(damageIndicatorsFrom[i] - GetComponent <PlayerMove>().mainCamera.transform.position) * Quaternion.Inverse(GetComponent <PlayerMove>().mainCamera.transform.rotation);
float angleUsed = -rotation.eulerAngles.y + 90f;
damageIndicators[i].GetComponent <RectTransform>().anchoredPosition = new Vector2(0 + 1.6f * Mathf.Cos(angleUsed * Mathf.PI / 180f) * 200, 0 + Mathf.Sin(angleUsed * Mathf.PI / 180f) * 200);
damageIndicators[i].GetComponent <RectTransform>().rotation = Quaternion.Euler(0, 0, angleUsed);
if (Time.time - damageIndicatorsTime[i] > 1f)
{
Color color = damageIndicators[i].GetComponent <RawImage>().color;
damageIndicators[i].GetComponent <RawImage>().color = new Color(color.r, color.g, color.b, damageIndicatorsTime[i] - Time.time + 2.0f);
}
}
// See player name & your trigger / trap.
PlayerMove pMove = GetComponent <PlayerMove>();
displayName = "";
RaycastHit hit;
float dist = 50;
// It should be noted that it has to hit the hitboxes, not the player right now because otherwise it would just the raycast would always hit your own player.. (Easy fix is just to move the raycast forward)
if (Physics.Raycast(pMove.mainCamera.transform.position, pMove.mainCamera.transform.forward, out hit, dist, LayerLogic.HitscanShootLayer()))
{
if (hit.transform.gameObject.layer == 16 + pMove.GetComponent <Combat>().team || hit.transform.gameObject.layer == 17 - pMove.GetComponent <Combat>().team) // Can see both allies and enemies right now.
{
// Finds the actual player object
Transform plyr = hit.transform;
do
{
plyr = plyr.parent;
} while (plyr.GetComponent <Combat>() == null);
if (plyr.GetComponent <PlayerMove> ()) // facades don't have names for now..
{
short playerOwner = plyr.GetComponent <PlayerMove> ().plyr;
if (GameManager.PlayerExists(playerOwner))
{
displayName = GameManager.GetPlayer(playerOwner).playerName;
}
}
}
if (hit.transform.gameObject.layer == 14)
{
if (hit.transform.GetComponent <ArrowLauncher>())
{
if (hit.transform.GetComponent <ArrowLauncher>().playerOwner == pMove.plyr) // "myArrowTrap"
{
hit.transform.GetComponent <ArrowLauncher>().Highlight();
}
}
if (hit.transform.GetComponent <ArrowTrigger>())
{
if (hit.transform.GetComponent <ArrowTrigger>().playerOwner == pMove.plyr) // "myArrowTrap"
{
hit.transform.GetComponent <ArrowTrigger>().Highlight();
}
}
}
}
}
if (OperationNetwork.isServer)
{
// Loss of overheal over time:
if (health > maxHealth && (int)(Time.time) > (int)(Time.time - Time.deltaTime)) // This = every second.
{
TakeDamage(Mathf.Min(5, health - maxHealth), OTHER); // Every second, lose 5 of the buff.
}
// You get healed within your respawn room:
if (GetComponent <PlayerMove>() && GetComponent <PlayerMove>().isInSpawnRoom&& health < maxHealth && (int)(Time.time) > (int)(Time.time - Time.deltaTime))
{
TakeDamage(Mathf.Max(-50, health - maxHealth), HEALING); // 50 heal per second in spawn.
}
}
if (!renderHealthBar && this.renderHealthBar)
{
this.renderHealthBar = false;
if (healthBar != null)
{
healthBar.GetComponent <Renderer>().enabled = false;
healthBar.parent.GetComponent <Renderer>().enabled = false;
}
}
// Assign to its own game object:
// Needs to be at least 10 buffed to get particle effect:
if (health <= maxHealth + 10 && isOverHealEffectDisplayed)
{
isOverHealEffectDisplayed = false;
transform.Find("OverHealParticles").gameObject.SetActive(false);
}
else if (health > maxHealth + 10 && !isOverHealEffectDisplayed)
{
isOverHealEffectDisplayed = true;
transform.Find("OverHealParticles").gameObject.SetActive(true);
}
}
// STATIC IMPLEMENTATIONS:
// In no particular order.
public static Vector3[] hitscanShoot(Vector3 pos, Vector3 fireFromPos, Vector3 forward, GameObject fireFrom, PlayerAnimation playerAnim, GameObject soundEffect, string bulletType, int team, float damage, float knockBackMult, int damageFallOff, float maxDistance, int shotgun, HitscanGun hsGun, out Combat playerHit, out float damageDone, short playerSender)
{
bool isPlayerHitscan = pos != fireFromPos; // Hitscan ALWAYS fires from a different location than the face. The sentry fires from the same place, and thus is a "serverObject" technically.
playerHit = null;
damageDone = 0;
RaycastHit hit;
float dist = maxDistance;
int layersToHit = LayerLogic.HitscanShootLayer(team); // Can't hit own team.
List <Vector3> positions = new List <Vector3>();
positions.Add(fireFromPos); // The effect comes from the gun
Vector3 lastPos = pos;
int numHitMirror = 0;
bool hitscanHitSomething = false;
while (Physics.Raycast(pos, forward, out hit, dist, layersToHit)) // Not ignore mirror, players, or placement, or ragdolls, not decor, of course
{
// Allied Building can be hit. Most "ignore this"
if ((hit.transform.CompareTag("Shield") || hit.transform.CompareTag("ShieldParent")) && (hit.transform.gameObject.layer - 10) / 5 == team)
{
// ignore the shield:
pos = hit.point + forward * 0.01f; // This "distance" reduces performance on these hitscan bullets significantly..
dist -= 0.01f; // As to prevent an infinite loop. (Could be an issue)
continue;
}
// add it.
lastPos = hit.point;
dist -= hit.distance; // Note how this could be used to calculate damage falloff.
pos = hit.point;
positions.Add(pos);
if (!hit.transform.CompareTag("Mirror"))
{
if (fireFrom != null || OperationNetwork.isServer)
{
// This is a COPY-PASTE (Similar) to Projectile.directHit()
if (hit.transform.gameObject.layer == 17 - team)
{
// Finds the actual player object
Transform plyr = hit.transform;
do
{
plyr = plyr.parent;
} while (plyr.GetComponent <Combat> () == null);
float dmg = getDamage(damage, dist / maxDistance, damageFallOff);
// Headshots no longer do any extra damage.
// Instead of doing damage, add up the damage, then do the damage.. in the case that this is a shotgun scenario:
if (shotgun == 0)
{
plyr.GetComponent <Combat> ().TakeDamage(dmg, knockBackMult, forward, false, Combat.SINGLE_BULLET, playerAnim != null, fireFromPos, playerSender);
}
else if (shotgun == 1)
{
playerHit = plyr.GetComponent <Combat> ();
damageDone = dmg;
}
}
else if (hit.transform.gameObject.layer == 10 || hit.transform.gameObject.layer == 15 || hit.transform.gameObject.layer == 20 || hit.transform.gameObject.layer == 21)
{
if (PlayerMade.IsFriendlyIcicle(hit.transform, team)) // General Exception
{
PlayerMade.TakeDamageObjectG(hit.transform, getDamage(damage, dist / maxDistance, damageFallOff) * 1000, fireFromPos, isPlayerHitscan, playerSender);
}
else if (PlayerMade.IsFriendlyThrowable(hit.transform, team)) // Specific Exception
{
PlayerMade.TakeDamageObjectG(hit.transform, getDamage(damage, dist / maxDistance, damageFallOff) * ThrowableSync.OWN_TEAM_MULTIPLIER, fireFromPos, isPlayerHitscan, playerSender);
}
else if (PlayerMade.IsEnemy(hit.transform, team) || PlayerMade.IsFriendlyThrowable(hit.transform, team)) // It must hit a shield / shieldparent.. note that shieldparent's usefulness is deprecated / icicle, AND hit an enemy.
{
PlayerMade.TakeDamageObjectG(hit.transform, getDamage(damage, dist / maxDistance, damageFallOff), fireFromPos, isPlayerHitscan, playerSender);
// Damage to buildings do not have damage numbers associated with them.. any damage saved would just be added up.
}
}
}
// The positions are instantly used for Player: (Or server)
if (fireFrom != null)
{
createBullet(positions.ToArray(), fireFrom, playerAnim, soundEffect, bulletType);
}
hitscanHitSomething = true;
break;
}
// Hit mirror:
forward = Vector3.Reflect(forward, hit.normal);
if (team == hit.transform.GetComponent <MirrorLogic>().team)
{
damage *= 2; // Twice the damage.
}
numHitMirror++;
if (numHitMirror >= 16) // Maximum 16 hits on mirror. Probably going to have max 1 mirror anyways
{
break;
}
}
if (!hitscanHitSomething)
{
positions.Add(pos + forward * dist);
if (fireFrom != null)
{
createBullet(positions.ToArray(), fireFrom, playerAnim, soundEffect, bulletType);
}
}
return(positions.ToArray());
}
/// <summary>
/// Job with menu
/// </summary>
public static void JobWithMenu()
{
bool mQuit = false;
int choiceNomMenu = 0;
Controller.ShowMenuInConsole();
while (!mQuit)
{
if (!Int32.TryParse(Console.ReadLine(), out choiceNomMenu) || !(choiceNomMenu >= 1 && choiceNomMenu <= 7))
{
Console.ForegroundColor = (ConsoleColor)ConsoleColors.EnumConsoleColors.ErrorOrOther;
Console.WriteLine("\t Invalid input. Try again:");
ShowMenuInConsole();
continue;
}
switch (choiceNomMenu)
{
case (int)MenuItem.DefaultCalc:
LayerLogic.DefaultCalc();
ShowMenuInConsole();
break;
case (int)MenuItem.InputFromAndTo:
bool prInputFromAndTo = false;
int _from, _to;
do
{
Console.Write("Input From:");
prInputFromAndTo = int.TryParse(Console.ReadLine(), out _from) && _from >= 1;
} while (!prInputFromAndTo);
do
{
Console.Write("Input To:");
prInputFromAndTo = int.TryParse(Console.ReadLine(), out _to) && _to > _from;
} while (!prInputFromAndTo);
LayerLogic.InputFromAndTo(_from, _to);
ShowMenuInConsole();
break;
case (int)MenuItem.InputPrimeFactors:
bool prInputPrimeFactors = false;
int _primeFirst, _primeSecond;
do
{
Console.Write("Input PrimeFirst[Fizz]:");
prInputPrimeFactors = int.TryParse(Console.ReadLine(), out _primeFirst) && LayerLogic.IsPrime(_primeFirst);
} while (!prInputPrimeFactors);
do
{
Console.Write("Input PrimeSecond[Buzz]:");
prInputPrimeFactors = int.TryParse(Console.ReadLine(), out _primeSecond) && LayerLogic.IsPrime(_primeSecond) && _primeFirst != _primeSecond;
} while (!prInputPrimeFactors);
LayerLogic.InputPrimeFactors(_primeFirst, _primeSecond);
ShowMenuInConsole();
break;
case (int)MenuItem.DefaultAsyncCalc:
WorkWithSynglton();
ShowMenuInConsole();
break;
case (int)MenuItem.AsyncInputFromAndTo:
bool prAsyncInputFromAndTo = false;
int _fromAsync, _toAsync;
do
{
Console.Write("Input From:");
prAsyncInputFromAndTo = int.TryParse(Console.ReadLine(), out _fromAsync) && _fromAsync >= 1;
} while (!prAsyncInputFromAndTo);
do
{
Console.Write("Input To:");
prAsyncInputFromAndTo = int.TryParse(Console.ReadLine(), out _toAsync) && _toAsync > _fromAsync;
} while (!prAsyncInputFromAndTo);
WorkWithSynglton(fromAsync: _fromAsync, toAsync: _toAsync);
ShowMenuInConsole();
break;
case (int)MenuItem.AsyncInputPrimeFactors:
bool prAsyncInputPrimeFactors = false;
int _primeFirstAsync, _primeSecondAsync;
do
{
Console.Write("Input PrimeFirst[Fizz]:");
prAsyncInputPrimeFactors = int.TryParse(Console.ReadLine(), out _primeFirstAsync) && LayerLogic.IsPrime(_primeFirstAsync);
} while (!prAsyncInputPrimeFactors);
do
{
Console.Write("Input PrimeSecond[Buzz]:");
prAsyncInputPrimeFactors = int.TryParse(Console.ReadLine(), out _primeSecondAsync) && LayerLogic.IsPrime(_primeSecondAsync) && _primeFirstAsync != _primeSecondAsync;
} while (!prAsyncInputPrimeFactors);
WorkWithSynglton(primeFirst: _primeFirstAsync, primeSecond: _primeSecondAsync);
ShowMenuInConsole();
break;
case (int)MenuItem.Quit:
Console.WriteLine("\t Quitting...");
mQuit = true;
break;
default:
break;
}
}
}
public bool walkingThroughWalls = false; // hmm
public bool RunPlayerAndServer(PlayerInput pI, Vector3 moveDir, Transform t)
{
if (!walkingThroughWalls)
{
// We first need to detect if you are walking STRAIGHT into a wall:
RaycastHit hit;
float fullRadius = t.GetComponent <CapsuleCollider> ().radius *t.localScale.x;
if (Physics.Raycast(t.position, t.rotation * Vector3.forward, out hit, 0.025f + fullRadius, LayerLogic.WorldColliders()) &&
Physics.Raycast(t.position, t.rotation * Vector3.forward, out hit, 0.025f + fullRadius, LayerLogic.WorldColliders())) // Possibly you can only walk into default colliders
{
if (moveDir.z > 0)
{
// The character is "walking into a wall"
// Enter!
if (Physics.Raycast(t.position, hit.normal, out hit, 18f, LayerLogic.WorldColliders()))
{
float radius = fullRadius * 0.69f; // 1.0f would be full. Note 0.7f is necessary for diagonals
float height = t.GetComponent <CapsuleCollider> ().height *t.localScale.x * 0.41f; // 0.5f would be full
if (Physics.OverlapBox(hit.point + hit.normal * t.GetComponent <CapsuleCollider>().radius *t.localScale.x,
new Vector3(radius, height, radius)).Length == 0)
{
posA = t.position;
dir = t.rotation * Vector3.forward;
travelPercent = 0;
walkingThroughWalls = true;
posB = hit.point + hit.normal * t.GetComponent <CapsuleCollider>().radius *t.localScale.x;
}
}
}
}
return(false);
}
else
{
// For now, you can't move backwards
travelPercent += (pI.frameTime * 4f); // Auto move
if (travelPercent < 0.5f)
{
t.position = posA + dir * t.GetComponent <CapsuleCollider> ().radius *t.localScale.x *travelPercent * 4;
}
else
{
t.position = posB - dir * t.GetComponent <CapsuleCollider> ().radius *t.localScale.x *(1 - travelPercent) * 4;
}
// Also set transparency..
if (travelPercent > 1)
{
travelPercent = -1; // Note, INTERP!! (-1 should be an exception to interp for float TODO!!)
walkingThroughWalls = false;
t.position = posB;
}
return(true);
}
// The initial entrance location is the "legal" location. (Also the exit point, of course)
}
// It includes render functionality, but this is optional.
// Blow up check occurs on server, of course.
// All functionality should be in the method parameters:
// "healthTaken" is set to -1 if it is NOT use healthTaken exploding functinality - this functionality is currently hard coded into this method for simplicity.
// fromWhere should generally be set to position, as it is where the blast supposedly comes from.
public static void BlowUp(Vector3 position, Vector3 fromWhere, float damage, float range, float minPercentDamage, float knockBackMult, GameObject exception, int team, ref float healthTaken, short playerSender)
{
// Set position to fromWhere to have the explosion be "standard"
Collider[] colliders = Physics.OverlapSphere(position, range, LayerLogic.BlowUpLayer());
List <PlayerMade> playerMadeObjectsHit = new List <PlayerMade> ();
List <float> playerMadeObjectsDamageDone = new List <float> ();
for (int i = 0; i < colliders.Length; i++)
{
Vector3 ccp = colliders [i].ClosestPointOnBounds(position);
float distance = Vector3.Distance(position, ccp);
if (distance > range)
{
Debug.LogError("Object out of range! ExplodeDetection -> BlowUp");
damage = 0f;
continue;
}
else
{
damage = getDamage(damage, distance, range, minPercentDamage); //(range - distance) / range) * damage * (1 - minPercentDamage) + damage * minPercentDamage;
}
// Line of sight, essentially
RaycastHit hit;
if (Physics.Raycast(position, Vector3.Normalize(ccp - position), out hit, distance, LayerLogic.BlowUpSeeIfLineOfSightLayer(team)))
{
// invalid..
continue;
}
// Reverse check, (very important; this one is really the required one.)
if (Physics.Raycast(ccp, -Vector3.Normalize(ccp - position), out hit, distance, LayerLogic.BlowUpSeeIfLineOfSightLayer(team)))
{
// invalid..
continue;
}
if (colliders[i].gameObject.layer == 8 + team * 14 && !(colliders[i] is CharacterController))
{
Combat hitPlayer = colliders [i].gameObject.GetComponent <Combat> ();
if (hitPlayer.GetComponent <SyncPlayer> ().playerOwner == playerSender)
{
if (healthTaken == -1)
{
// EXACT same code as is done to enemies: NOTICE how instead of ccp, hitPlayer.transform.position is used to calculate the direction in which the force takes place
hitPlayer.TakeDamage(damage, knockBackMult, Vector3.Normalize(hitPlayer.transform.position - fromWhere), false, Combat.BLOW_UP, false, fromWhere, playerSender);
}
}
else if (healthTaken != -1) // Can't heal yourself
// HEALING:
{
if (hitPlayer.gameObject != exception && hitPlayer.health < hitPlayer.maxHealth)
{
float maxHealthTaken = Mathf.Min(healthTaken, 50);
healthTaken += (-Mathf.Min(hitPlayer.maxHealth - hitPlayer.health, maxHealthTaken));
hitPlayer.TakeDamage(Mathf.Max(hitPlayer.health - hitPlayer.maxHealth, -maxHealthTaken), 0, Vector3.zero, false, Combat.HEALING, true, fromWhere, playerSender);
}
}
}
else if (colliders[i].gameObject.layer == 22 - team * 14 && !(colliders[i] is CharacterController))
{
Combat hitPlayer = colliders[i].gameObject.GetComponent <Combat>();
if (hitPlayer.gameObject != exception)
{
if (healthTaken != -1)
{
// "TAKE HEALTH"
// This is completely based on player's health, rather than damage done:
healthTaken += (Mathf.Min((25 + hitPlayer.health * 0.5f), 80));
}
// NOTICE how instead of ccp, hitPlayer.transform.position is used to calculate the direction in which the force takes place
hitPlayer.TakeDamage(damage, knockBackMult, Vector3.Normalize(hitPlayer.transform.position - fromWhere), false, Combat.BLOW_UP, false, fromWhere, playerSender);
}
}
else if (colliders[i].gameObject.layer == 10 + team * 5)
{
if (healthTaken != -1 && PlayerMade.IsFriendlyBuilding(colliders[i].transform, team))
{
// HEALING:
// Heal this building:
PlayerMade pMade = PlayerMade.GetPlayerMade(colliders[i].transform);
if (!playerMadeObjectsHit.Contains(pMade) && pMade.gameObject != exception && pMade.getHealth() < pMade.getMaxHealth())
{
// Note how damage is not used, range doesn't matter here!
playerMadeObjectsHit.Add(pMade); // This is important, to prevent multiple hits
playerMadeObjectsDamageDone.Add(0); // NOT USED for healthTaken
float maxHealthTaken = Mathf.Min(healthTaken, 50); // Can only heal 50 in one burst. (Note: you can technically hit more than one player at once)
healthTaken += (-Mathf.Min(pMade.getMaxHealth() - pMade.getHealth(), maxHealthTaken));
pMade.TakeDamageObject((short)Mathf.RoundToInt(Mathf.Max(pMade.getHealth() - pMade.getMaxHealth(), -maxHealthTaken)), fromWhere, false, playerSender);
}
}
}
else if (colliders[i].gameObject.layer == 15 - team * 5)
{
if (PlayerMade.IsEnemy(colliders[i].transform, team))
{
PlayerMade pMade = PlayerMade.GetPlayerMade(colliders[i].transform);
// Kind of redundant because TakeDamageObjectG finds pMade, but it's generalized.
if (pMade.gameObject != exception)
{
int indexOfPMO = playerMadeObjectsHit.IndexOf(pMade);
if (indexOfPMO != -1)
{
if (damage > playerMadeObjectsDamageDone [indexOfPMO])
{
playerMadeObjectsDamageDone [indexOfPMO] = damage;
}
}
else
{
playerMadeObjectsHit.Add(pMade);
playerMadeObjectsDamageDone.Add(damage);
}
}
}
}
}
for (int i = 0; i < playerMadeObjectsHit.Count; i++)
{
PlayerMade.TakeDamageObjectG(playerMadeObjectsHit[i].transform, playerMadeObjectsDamageDone[i], fromWhere, false, playerSender);
}
}
// Update is called once per frame
void Update()
{
if (GetComponent <Camera>().enabled&& OptionsMenu.IsLockState())
{
// Controls for SPECTATOR CAMERA!!
float v = Input.GetAxis("Vertical");
float h = Input.GetAxis("Horizontal");
transform.position += transform.TransformDirection(new Vector3(h * 5f * Time.deltaTime, 0, v * 5f * Time.deltaTime));
float xRot = transform.eulerAngles.x - Input.GetAxis("Mouse Y") * PlayerMove.sensitivity;
if ((xRot < PlayerMove.minimumY) || (xRot >= 180 && xRot < 360 + PlayerMove.minimumY))
{
xRot = PlayerMove.minimumY;
}
if ((xRot <= 180 && xRot > PlayerMove.maximumY) || (xRot > 360 + PlayerMove.maximumY))
{
xRot = PlayerMove.maximumY;
}
transform.eulerAngles = new Vector3(xRot,
transform.eulerAngles.y + Input.GetAxis("Mouse X") * PlayerMove.sensitivity,
transform.eulerAngles.z);
// See player names:
// Almost identical to the implementation in Combat. (Should be a method, todo)
PlayerMove pMove = GetComponent <PlayerMove>();
displayName = "";
RaycastHit hit;
float dist = 50;
// It should be noted that it has to hit the hitboxes, not the player right now because otherwise it would just the raycast would always hit your own player.. (Easy fix is just to move the raycast forward)
if (Physics.Raycast(transform.position, transform.forward, out hit, dist, LayerLogic.HitscanShootLayer()))
{
if (hit.transform.gameObject.layer == 16 || hit.transform.gameObject.layer == 17)
{
// Finds the actual player object
Transform plyr = hit.transform;
do
{
plyr = plyr.parent;
} while (plyr.GetComponent <Combat> () == null);
if (plyr.GetComponent <PlayerMove> ())
{
short id = plyr.GetComponent <PlayerMove> ().plyr;
if (GameManager.PlayerExists(id))
{
displayName = GameManager.GetPlayer(id).name;
}
}
}
}
}
}
