/// <summary>
///
/// </summary>
/// <param name="actionType"></param>
public virtual void StartAction(GameActionTypeEnum actionType)
{
if (CurrentAction != null && CurrentAction.Type == actionType)
{
CurrentAction.Start();
}
switch (actionType)
{
case GameActionTypeEnum.MAP:
Map.SpawnEntity(this);
break;
case GameActionTypeEnum.SKILL_HARVEST:
case GameActionTypeEnum.MAP_MOVEMENT:
MovementHandler.Dispatch(WorldMessage.GAME_ACTION(actionType, Id, CurrentAction.SerializeAs_GameAction()));
break;
case GameActionTypeEnum.MAP_TELEPORT:
StopAction(GameActionTypeEnum.MAP);
StopAction(GameActionTypeEnum.MAP_TELEPORT);
// Switch back to world context
WorldService.Instance.AddUpdatable(this);
break;
}
}
private void KeyboardAction(KeyboardState kbState)
{
foreach (var key in this.KbKeys.Where(kbState.IsKeyDown))
{
switch (key)
{
case Keys.D:
MovementHandler.MoveRight(this);
this.MovementAngle = GlobalVariables.RightAngle;
break;
case Keys.W:
MovementHandler.MoveUp(this);
this.MovementAngle = GlobalVariables.UpAngle;
break;
case Keys.S:
MovementHandler.MoveDown(this);
this.MovementAngle = GlobalVariables.DownAngle;
break;
case Keys.A:
MovementHandler.MoveLeft(this);
this.MovementAngle = GlobalVariables.LeftAngle;
break;
}
CollisionHandler.PlayerReaction(this, key);
}
}
public static void ExistingOrCreateNewMainCamera()
{
GameObject TempCamera;
Transform targetLookAt;
CameraController MyCamera;
if (Camera.main != null)
{
TempCamera = Camera.main.gameObject;
}
else
{
TempCamera = new GameObject("Main Camera");
TempCamera.AddComponent <Camera>();
TempCamera.AddComponent <AudioListener>();
TempCamera.AddComponent <AudioSource>();
TempCamera.AddComponent <FlareLayer>();
TempCamera.tag = ("MainCamera");
}
TempCamera.AddComponent <CameraController>();
MyCamera = TempCamera.GetComponent("CameraController") as CameraController;
targetLookAt = MovementHandler.getInstance().lookAt;
if (targetLookAt == null)
{
GameObject targetObject = new GameObject("cameraTarget");
targetLookAt = targetObject.transform;
targetLookAt.transform.parent = MovementHandler.getInstance().gameObject.transform;
targetLookAt.transform.localPosition = new Vector3(0f, 0.25f, 0f);
}
MyCamera.TargetLookAt = targetLookAt.transform;
}
public override void Process(CmdTrigger <RealmServerCmdArgs> trigger)
{
var vertSpeed = trigger.Text.NextFloat();
var horSpeed = trigger.Text.NextFloat(vertSpeed);
MovementHandler.SendKnockBack(trigger.Args.Character, trigger.Args.Target, vertSpeed, horSpeed);
}
internal (bool startMovement, PointI hexToMoveTo) CheckForUnitMovementFromMouseInitiation(Point mouseLocation)
{
MovementHandler.HexLibrary = HexLibrary;
var startUnitMovement = MovementHandler.CheckForUnitMovement(MovementHandler.CheckForUnitMovementFromMouseInitiation, Stack, (WorldView.CellGrid, mouseLocation, WorldView.Camera));
return(startUnitMovement);
}
internal (bool startMovement, PointI hexToMoveTo) CheckForUnitMovementFromKeyboardInitiation(Keys key)
{
MovementHandler.HexLibrary = HexLibrary;
var startUnitMovement = MovementHandler.CheckForUnitMovement(MovementHandler.CheckForUnitMovementFromKeyboardInitiation, Stack, key);
return(startUnitMovement);
}
void Awake()
{
movementHandler = GetComponent<MovementHandler>();
controller = movementHandler.controller;
cam = movementHandler.cam;
gravity = GetComponent<Gravity>();
}
void OnMouseUp()
{
if (xAxisFree || yAxisFree)
{
yAxisFree = false;
xAxisFree = false;
if (translatedObjects != null && translatedObjects.Count > 0)
{
while (translatedObjects.Count > 0)
{
FieldElement tempField = new FieldElement(new Vector2(100, 100));
foreach (FieldElement field in translatedObjects)
{
if (Vector2.Distance(field.Coordinate, FieldContainer.GetFreeFieldElement().Coordinate) < Vector2.Distance(tempField.Coordinate, FieldContainer.GetFreeFieldElement().Coordinate))
{
tempField = field;
}
}
MovementHandler.newHoldPoint(tempField.fieldObject);
tempField.fieldObject.transform.DOLocalMove(MovementHandler.GetObjectPosition(tempField.fieldObject), 0.5f);
translatedObjects.Remove(tempField);
}
translatedObjects.Clear();
}
MovementHandler.newHoldPoint(this.gameObject);
gameObject.transform.DOLocalMove(MovementHandler.GetObjectPosition(this.gameObject), 0.5f);
ResultHandler.CheckResult();
}
}
void SpawnPeasants()
{
peasants = new List <GameObject>();
for (var i = 0; i < numberOfPeasants; i++)
{
GameObject peasant = Instantiate(peasantPrefab, spawnPoint.position + new Vector3(i * spawnOffset, 0, 0), Quaternion.LookRotation(Vector3.forward, Vector3.up));
var visHandler = peasant.GetComponent <VisualHandler>();
if (visHandler)
{
visHandler.chestID = Random.Range(2, 6);
visHandler.headID = Random.Range(2, 6);
visHandler.legsID = Random.Range(2, 6);
}
MovementHandler movementHandler = peasant.GetComponent <MovementHandler>();
peasants.Add(peasant);
if (movementHandler != null)
{
float speed = Random.Range(minSpeed, maxSpeed);
movementHandler.speed = speed;
movementHandler.destination = destination.position + new Vector3(i * positionOffset / numberOfPeasants + Random.Range(-randomOffsetX, randomOffsetX), Random.Range(-randomOffsetY, randomOffsetY) * numberOfPeasants, 0);
}
}
}
private void AddToMovementList(MovementHandler newMovement)
{
foreach (BodyController controller in bodyControllers)
{
controller.movement.Add(newMovement);
}
}
private void Awake()
{
rb = GetComponent <Rigidbody>();
velocityLine = GetComponent <LineRenderer>();
movementHandler = GetComponent <MovementHandler>();
defaultFov = mainCamera.fieldOfView;
}
void RpcSetBullet(GameObject bullet, GameObject target)
{
if (!isServer)
{
MovementHandler movementHandler = bullet.GetComponent <MovementHandler>();
movementHandler.moveToTarget(target.transform, null);
}
}
public NetworkReceiver(BaseNetwork baseNetwork)
{
m_UnityServer = UnityServer.Instance;
m_BaseNetwork = baseNetwork;
m_LoginHandler = new LoginHandler();
m_MovementHandler = new MovementHandler();
}
public override void Process(CmdTrigger <RealmServerCmdArgs> trigger)
{
float num = trigger.Text.NextFloat();
float verticalSpeed = trigger.Text.NextFloat(num);
MovementHandler.SendKnockBack(trigger.Args.Character, trigger.Args.Target, num,
verticalSpeed);
}
void Awake()
{
rh = FindObjectOfType <RotationHandler>();
mh = FindObjectOfType <MovementHandler>();
rotationStatusText = GameObject.Find("RotationStatusText").GetComponent <Text>();
movementStatusText = GameObject.Find("MovementStatusText").GetComponent <Text>();
}
// Use this for initialization
void Start()
{
_input = GameObject.Find("GameController").GetComponent <InputHandler> ();
_health = GetComponent <HealthHandler> ();
_move = GetComponent <MovementHandler> ();
_shoot = GetComponent <ShootHandler> ();
_collision = GetComponent <CollisionHandler> ();
}
public override void Spawn(TriggerManager tm)
{
if (this.scene == GameManager.instance.sceneName)
{
this.go = new GameObject();
this.movementHandler = go.AddComponent <MovementHandler>().Initialize(this.logic, tm);
}
}
// Our method to finish path logic on the request manager, and pass a callback method
// to whatever unit was asking for the path in the first place.
public void FinishedProcessingPath(Vector3[] path, bool success, MovementHandler movementHandler)
{
// Pass the path vector3[] and status of success/failure to the interested unit
currentPathRequest.callback(path, success);
// Reset our manager's statemachine so it can accept/process additional path requests.
isProcessingPath = false;
TryProcessNext(movementHandler);
}
public override void Load(ContentManager content)
{
PlayerTextureLeft = content.Load <Texture2D>("playerleft");
PlayerTextureRight = content.Load <Texture2D>("playerright");
PlayerTexture = PlayerTextureRight;
PlayerRectangle = new Rectangle((int)PlayerPosition.X, (int)PlayerPosition.Y, PlayerTexture.Width, PlayerTexture.Height);
PlayerMoves += inJump;
PlayerMoves += inFall;
}
private void Awake()
{
animator = GetComponent <Animator>();
shieldAbility = GetComponent <ShieldAbility>();
movementHandler = GetComponent <MovementHandler>();
//Debug.Log(animator.GetCurrentAnimatorStateInfo(0));
}
void Start()
{
//Added for character loading system. Needs to start here for it to work
if (SceneManager.GetActiveScene().name != "TrainingStage")
{
if (transform.parent.name == "Player1")
{
Horizontal = "Horizontal_P1";
Vertical = "Vertical_P1";
L3 = "L3_P1";
opponent = GameObject.Find("Player2").transform.GetChild(0).transform;
}
else
{
Horizontal = "Horizontal_P2";
Vertical = "Vertical_P2";
L3 = "L3_P2";
opponent = GameObject.Find("Player1").transform.GetChild(0).transform;
}
OpponentProperties = opponent.GetComponent <CharacterProperties>();
}
//
Application.targetFrameRate = 60;
pushBox.enabled = true;
pushBox.offset = pushCenter;
pushBox.size = pushSize;
sigil = Instantiate(sigilPrefab, new Vector3(transform.position.x, transform.position.y, transform.position.z), Quaternion.identity, transform.root);
if (sigilImage != null)
{
sigil.GetComponent <SpriteRenderer>().sprite = sigilImage;
}
sigil.GetComponent <SpriteRenderer>().color = sigilTint;
sigil.GetComponent <Sigil>().tint = sigilTint;
opponentMove = opponent.GetComponent <MovementHandler>();
airID = Animator.StringToHash("Airborne");
crouchID = Animator.StringToHash("Crouch");
runID = Animator.StringToHash("Run");
walkFID = Animator.StringToHash("WalkForward");
walkBID = Animator.StringToHash("WalkBack");
backDashID = Animator.StringToHash("Backdash");
jumpID = Animator.StringToHash("Jump");
landID = Animator.StringToHash("Land");
lowGuardID = Animator.StringToHash("LowGuard");
highGuardID = Animator.StringToHash("HighGuard");
airGuardID = Animator.StringToHash("AirGuard");
hitAirID = Animator.StringToHash("HitAir");
wallStickID = Animator.StringToHash("WallStick");
groundBounceID = Animator.StringToHash("GroundBounce");
wallBounceID = Animator.StringToHash("WallBounce");
yVeloID = Animator.StringToHash("VertVelocity");
KOID = Animator.StringToHash("KOed");
KDID = Animator.StringToHash("KnockDown");
}
/// <summary>
/// Stops at the current position
/// </summary>
public void Stop()
{
if (m_moving)
{
UpdatePosition();
MovementHandler.SendStopMovementPacket(m_owner);
m_moving = false;
}
}
void Awake()
{
movementHandler = GetComponent <MovementHandler>();
controller = movementHandler.controller;
playerManager = GetComponentInParent <PlayerManager>();
cam = movementHandler.cam;
gravity = GetComponent <Gravity>();
inputSpeed = walkSpeed;
}
public void HandleAttack(Dictionary <string, object> Params, int ID, object Caller)
{
object attackerObj, defenderObj;
Params.TryGetValue("Attacker", out attackerObj);
BaseUnit attacker = attackerObj as BaseUnit;
Params.TryGetValue("Defender", out defenderObj);
BaseUnit defender = defenderObj as BaseUnit;
// Damage calculation
Debug.Log(attacker.unitName + " makes an attack on " + defender.unitName + "...");
float damage = CalculateDamage(attacker, defender);
Debug.Log(defender.unitName + " takes " + damage + " points of damage.");
if (damage >= defender.currHP)
{
Vector2Int nPos = new Vector2Int(defender.xPos, defender.yPos);
Debug.Log(defender.unitName + " dies in battle.");
defender.currHP = 0;
defender.onDeath();
if (attacker.RNG == 1 && attacker.boardSpace.movePiece(new Vector2Int(attacker.xPos, attacker.yPos), nPos))
{
// We succeeded a move on the board space so we can update the SO now
MovementHandler.Instance().moveEvent.raise(0, this, new Dictionary <string, object> {
{ "Unit", attacker },
{ "x", nPos.x },
{ "y", nPos.y }
});
}
return;
}
defender.currHP -= damage;
// Check to see if the defender gets a counter attack
int dist = (attacker.xPos - defender.xPos) + (attacker.yPos - attacker.yPos);
if (dist <= defender.RNG)
{
int counterRoll = dice.Next(0, 100);
if (counterRoll >= 100 - defender.CTR * 100)
{
Debug.Log(defender.unitName + " makes a counter attack...");
damage = CalculateDamage(defender, attacker);
Debug.Log(attacker.unitName + " takes " + damage + " points in damage.");
if (damage >= attacker.currHP)
{
Debug.Log(attacker.unitName + " dies in battle.");
attacker.currHP = 0;
attacker.onDeath();
return;
}
attacker.currHP -= damage;
}
}
}
public FollowPathToTargetAction(Transform character,
Transform target,
float movementSpeed,
LayerMask obstacleMask,
WaypointManager waypointManager,
MovementHandler movementHandler)
: base(character, movementSpeed, obstacleMask, waypointManager, movementHandler)
{
m_Target = target;
}
private void Start()
{
rb = GetComponent <Rigidbody2D>();
//Set in the Inspector
//rb.gravityScale = 0;
//rb.collisionDetectionMode = CollisionDetectionMode2D.Continuous;
//rb.constraints = RigidbodyConstraints2D.FreezeRotation;
movementHandler = GetComponent <MovementHandler>();
}
private static bool CheckFull(BaseInstance instance, Character chr)
{
if (instance.MaxPlayerCount == 0 || instance.PlayerCount < instance.MaxPlayerCount || chr.GodMode)
{
return(true);
}
MovementHandler.SendTransferFailure(chr.Client, instance.Id,
MapTransferError.TRANSFER_ABORT_MAX_PLAYERS);
return(false);
}
private void Start()
{
combatant = GetComponent <CombatHandler>();
playerTarget = GameObject.FindWithTag("Player");
healthManager = GetComponent <HealthManager>();
mover = GetComponent <MovementHandler>();
pather = GetComponent <PatrolPath>();
guardingPosition = transform.position;
}
public override void _Ready()
{
playerSprintParticles = GetNode <Particles2D>("PlayerSpriteParitcles");
inventory = GetNode <Inventory>("Inventory");
healthbar = GetTree().CurrentScene.GetNode <Healthbar>("Hud/HealtbarRoot");
movementHandler = new MovementHandler(400f, 70f, 200f, 250f, 500f, 350f);
Connect("SPlayerDied", GetTree().CurrentScene, "OnPlayerDied");
}
private void Start()
{
this.gameObject.tag = "Player";
maxHealth = 500;
minhealth = 0;
currHealth = 500;
ref_movement = GetComponent <MovementHandler> ();
ref_rgbdy = GetComponent <Rigidbody2D> ();
ref_animation = GetComponent <AnimationHandler> ();
}
void Start()
{
characterController = GetComponent<CharacterController>();
self = this;
canJump = true;
canMove = true;
externalMovementLock = false;
//We're so sorry (not sorry at all)
CameraController.ExistingOrCreateNewMainCamera();
}
