public void HandleTriggerWeight(int newTriggerWeight, string textSender, string textMessage)
{
Debug.Log ("prevTriggerWeight " + prevTriggerWeight + " newTriggerWeight " + newTriggerWeight);
Debug.Log ("playerDir " + playerDir);
bool sendText = true;
if (prevTriggerWeight == -1 || (prevTriggerWeight > newTriggerWeight && playerDir == PlayerDirection.WalkingInRightDir))
{
//you're still walking in the correct direction
textMessage += rightWay[rightWayIndex];
rightWayIndex +=1;
if (rightWayIndex == rightWay.Length)
rightWayIndex = rightWay.Length-1;
wrongWayIndex = 0;//reset
//playerDir = PlayerDirection.WalkingInRightDir
}
else if (prevTriggerWeight > newTriggerWeight && playerDir == PlayerDirection.WalkingInWrongDir)
{
//you were walking in the wrong direction, but now walking in the correct direction
textMessage += wrongToRightWay;
rightWayIndex = 0;
wrongWayIndex = 0;//reset
playerDir = PlayerDirection.WalkingInRightDir;
}
else if (prevTriggerWeight < newTriggerWeight && playerDir == PlayerDirection.WalkingInRightDir)
{
//you were walking in the correct direction, but now walking in the wrong direction
textMessage += rightToWrongWay;
rightWayIndex = 0;
wrongWayIndex = 0;//reset
playerDir = PlayerDirection.WalkingInWrongDir;
}
else if (prevTriggerWeight < newTriggerWeight && playerDir == PlayerDirection.WalkingInWrongDir)
{
//you're still walking in the wrong direction
textMessage += wrongWay[wrongWayIndex];
wrongWayIndex +=1;
if (wrongWayIndex == wrongWay.Length)
wrongWayIndex = wrongWay.Length-1;
rightWayIndex = 0;//reset
//playerDir = PlayerDirection.WalkingInWrongDir
}
//else you walked into a trigger box with the same weight as you already have. Probably the same trigger box
else
{
sendText = false;
}
if (sendText)
{
prevTriggerWeight = newTriggerWeight;
TextMessage txt = new TextMessage (textSender, textMessage);
string str = txt.ToString();
ps.PhoneUpdateText (str);
}
}
// Use this for initialization
void Start () {
//get the PlayerDirection.cs in the component
dir = this.GetComponent<PlayerDirection> ();
//get the character controller in the component
controller = this.GetComponent<CharacterController> ();
playerAttack = this.GetComponent<PlayerAttack>();
}
public void Execute(CharacterObservable character, PlayerDirection newDirection)
{
Receiver.SetUserAction(GameActions.RotateAction);
if (character.Direction == newDirection) return;
character.Direction = newDirection;
MakeCharacterRotate(character);
}
public PlayerBullet(PlayerDirection pDirection, Level pLevel)
: base("playerbullet.png")
{
_level = pLevel;
_direction = pDirection;
SetOrigin(width / 2, height / 2);
moveDirection();
}
public Rectangle UpdateSprite(GameTime gameTime, PlayerDirection direction, bool isDeadly)
{
Timer += (float)gameTime.ElapsedGameTime.TotalMilliseconds;
if (Timer > Interval)
{
CurrentFrame++;
if (CurrentFrame > FrameCount - 1)
{
const int positionOne = 0;
const int positionTwo = 50;
const int positionThree = 100;
const int postionFour = 150;
var directionCord = direction.Equals(PlayerDirection.Left) ? 74 : 148;
CurrentFrame = 0;
if(direction.Equals(PlayerDirection.None))
{
SourceRect = new Rectangle(100, 3, SpriteWidth, SpriteHeight);
}
else
{
if (_playerPosition.Equals(0))
{
SourceRect = new Rectangle(positionOne, directionCord, SpriteWidth, SpriteHeight);
if (!isDeadly)
SourceRect = new Rectangle(0, 0, 0, 0);
}
if (_playerPosition.Equals(1))
{
SourceRect = new Rectangle(positionTwo, directionCord, SpriteWidth, SpriteHeight);
}
if (_playerPosition.Equals(2))
{
SourceRect = new Rectangle(positionThree, directionCord, SpriteWidth, SpriteHeight);
if (!isDeadly)
SourceRect = new Rectangle(0, 0, 0, 0);
}
if (_playerPosition.Equals(3))
{
SourceRect = new Rectangle(postionFour, directionCord, SpriteWidth, SpriteHeight);
}
_playerPosition++;
if (_playerPosition.Equals(4))
_playerPosition = 0;
}
}
Timer = 0f;
}
return SourceRect;
}
public Player(Vector2 vecPosition, Texture2D texImage)
{
m_texImage = texImage;
m_vecPosition = vecPosition;
m_bAlive = true;
m_iFrame = 0;
m_iMaxFrames = 2;
m_plyrDirection = PlayerDirection.Right;
m_iFrameRate = 10;
m_iTicks = 0;
}
public Player()
{
m_texImage = null;
m_vecPosition = Vector2.Zero;
m_bAlive = true;
m_iFrame = 0;
m_iMaxFrames = 2;
m_plyrDirection = PlayerDirection.Right;
m_iFrameRate = 10;
m_iTicks = 0;
}
public Player()
{
m_onHideTile = true;
m_onExitTile = false;
m_direction = PlayerDirection.STILL;
m_movingDelayTimer = 0.0f;
m_standingDelayTimer = 0.0f;
m_hidingTimer = 0.0f;
m_HP = maxHP;
m_questItemOnHand = 0;
m_starOnHand = 0;
}
public void setInputDirection(PlayerDirection dir)
{
if (dir == PlayerDirection.UP && direction == PlayerDirection.DOWN ||
dir == PlayerDirection.DOWN && direction == PlayerDirection.UP ||
dir == PlayerDirection.RIGHT && direction == PlayerDirection.LEFT ||
dir == PlayerDirection.LEFT && direction == PlayerDirection.RIGHT)
{
return;
}
direction = dir;
forceMove();
}
//old Player
public Player(Player p)
: base(p.PosX, p.PosY, p.Width, p.Height, p.objectTexture, p.MaxHealth, p.MaxSpeed)
{
this.visionStandard = p.visionStandard;
playerVision = new Rectangle(p.PosX - visionStandard, p.PosY - visionStandard, width + (visionStandard * 2), height + (visionStandard * 2));
invincibleTimer = p.invincibleTimer;
invincibile = p.invincibile;
attackStuff = p.attackStuff;
attackAnimationF = p.attackAnimationF;
playerDirection = p.playerDirection;
}
void resetPosition()
{
direction = PlayerDirection.UP;
transform.rotation = Quaternion.LookRotation(Vector3.up, Vector3.forward);
if (this.name == "pacManSphere(Clone)")
{
SetOrigin(pacManStartPos);
}
else
{
SetOrigin(pacWomanStartPos);
}
}
public void SetUpInputDirection(PlayerDirection dir)
{
if (dir == PlayerDirection.UP && playerDirection == PlayerDirection.DOWN ||
dir == PlayerDirection.DOWN && playerDirection == PlayerDirection.UP ||
dir == PlayerDirection.RIGHT && playerDirection == PlayerDirection.LEFT ||
dir == PlayerDirection.LEFT && playerDirection == PlayerDirection.RIGHT)
{
return;
}
playerDirection = dir;
ForceMove();
}
void Start()
{
myRigidbody = GetComponent <Rigidbody2D>();
animator = GetComponent <Animator>();
spriteRenderer = GetComponent <SpriteRenderer>();
animator.SetFloat("move_x", 0);
animator.SetFloat("move_y", -1);
SetCanMove(true);
currentState = PlayerState.idle;
currentDirection = PlayerDirection.down;
transform.position = startingPosition.initialValue;
spriteRenderer.sprite = playerSprite.initialValue;
}
void Start()
{
tmpAxis = Vector2.zero;
OldTmpAxis = Vector2.zero;
curTmpCount = 0;
tmpCount = 2;
oldDirection = PlayerDirection.Down;
tmpDirection = PlayerDirection.Down;
axisX.InitAxis();
axisY.InitAxis();
sourceAnchoredPosition = cachedRectTransform.anchoredPosition;
}
public void SwipeCards()
{
foreach (var player in Players)
{
(_swipeDirection == PlayerDirection.RIGHT
? player.RightPlayerData
: player.LeftPlayerData).GiveCards(player.CardsToMove);
}
_swipeDirection = _swipeDirection == PlayerDirection.RIGHT
? PlayerDirection.LEFT
: PlayerDirection.RIGHT;
}
void Start()
{
controls = GetComponent <Controls>();
mainBody = GetComponent <Rigidbody2D>();
MyTransform = transform;
timer = 0f;
moveLength = 0.5f;
getSnakeOnList();
SetMovementBehaviour();
direction = PlayerDirection.UP; // at game start set snake facing left side
}
void RotateAvatar(bool isMoveRight)
{
if (dir == PlayerDirection.left && isMoveRight)
{
transform.GetChild(0).rotation = Quaternion.Euler(transform.GetChild(0).rotation.x, 0, transform.GetChild(0).rotation.z);
dir = PlayerDirection.right;
}
else if (dir == PlayerDirection.right && !isMoveRight)
{
transform.GetChild(0).rotation = Quaternion.Euler(transform.GetChild(0).rotation.x, 90, transform.GetChild(0).rotation.z);
dir = PlayerDirection.left;
}
}
void Start()
{
player_direction = PlayerDirection.DOWN;
state = State.NORMAL;
transform.position = new Vector3(0, 0, -1.0f);
vec = new Vector2(0, 0);
is_pusheventkey = false;
StartCoroutine(moveMethod());
StartCoroutine(fieldCheck());
StartCoroutine(stateCoroutine());
}
void setPlayerStateWithDirectionAcceleration()
{
Vector2 acceleration = Input.acceleration;
PlayerDirection direction = animatorController.Direction;
PlayerState state = animatorController.State;
if (ETCInput.GetButton("Stop"))
{
state = PlayerState.Idle;
}
else if (Mathf.Abs(acceleration.x) >= Mathf.Abs(acceleration.y))
{
if (Mathf.Abs(acceleration.x) >= 0.065f)
{
state = PlayerState.Movement;
if (acceleration.x < 0f)
{
direction = PlayerDirection.Left;
}
else
{
direction = PlayerDirection.Right;
}
}
else
{
state = PlayerState.Idle;
}
}
else
{
if (Mathf.Abs(acceleration.y) >= 0.065f)
{
state = PlayerState.Movement;
if (acceleration.y < 0f)
{
direction = PlayerDirection.Down;
}
else
{
direction = PlayerDirection.Up;
}
}
else
{
state = PlayerState.Idle;
}
}
animatorController.AcceptInput(direction, state);
movement.Movement(state, direction);
}
void Awake()
{
body = GetComponent <Rigidbody>();
CapsuleCollider collider = GetComponent <CapsuleCollider>();
grounded = true;
distToGround = collider.bounds.extents.y + 0.01f;
currentDirection = PlayerDirection.LEFT;
if (Instance == null)
{
Instance = this;
}
}
private IEnumerator Turn(PlayerDirection direction)
{
if (PlayerDirection.LEFT.Equals(direction))
{
setPlayerDirectionTurnLeft();
yield return(StartCoroutine(rotationLeft()));
}
else if (PlayerDirection.RIGHT.Equals(direction))
{
setPlayerDirectionTurnRight();
yield return(StartCoroutine(rotationRight()));
}
yield return(new WaitForSeconds(1f));
}
//Player Setting 함수
public void SetPlayer(int xPos, int yPos, int direction)
{
playerCoordinate = new Vector2(xPos, yPos);
Debug.Log("Set Player Direction " + direction);
playerGravityDirection = playerDirectionEnum[direction];
Debug.Log("Set Player Gravity Direction " + playerGravityDirection);
playerState = PlayerState.Idle;
transform.rotation = Quaternion.Euler(0, 0, ((int)playerGravityDirection + 2) * -90f);
transform.position = MapManager.instance.Get_MapTilePosition((int)playerCoordinate.x, (int)playerCoordinate.y);
spriteRenderer = this.GetComponentInChildren <SpriteRenderer>();
playerAnimator = this.GetComponentInChildren <Animator>();
playerAnimator.Play("Idle", -1, 0f);
}
/// <summary>
///
/// </summary>
private void Initialize()
{
for (int i = 0; i < sizeMatrix; i++)
{
for (int j = 0; j < sizeMatrix; j++)
{
matrix[i, j] = 0;
}
}
GenerateExit();
headPosition = new Point(1, 1);
matrix[1, 1] = 1;
playerDirection = PlayerDirection.Left;
}
/// <summary>
/// Method for console command evaluation
/// <remarks>
/// Can create maze, move player, show score, restart and exit
/// </remarks>
/// <param name="operator">
/// Accepts a string for further command parsing
/// </param>
/// </summary>
public void ExecuteCommand(string @operator)
{
switch (@operator)
{
case "small":
this.Command = PlayerCommand.CreateSmallMaze;
break;
case "medium":
this.Command = PlayerCommand.CreateMediumMaze;
break;
case "large":
this.Command = PlayerCommand.CreateLargeMaze;
break;
case "d":
this.Direction = PlayerDirection.Down;
break;
case "u":
this.Direction = PlayerDirection.Up;
break;
case "r":
this.Direction = PlayerDirection.Right;
break;
case "l":
this.Direction = PlayerDirection.Left;
break;
case "top":
this.Command = PlayerCommand.PrintTopScores;
break;
case "restart":
this.Command = PlayerCommand.Restart;
break;
case "exit":
this.Command = PlayerCommand.Exit;
break;
default:
this.Command = PlayerCommand.InvalidCommand;
this.PlayerMoved = false;
break;
}
}
public void SetInputDirection(PlayerDirection dir)
{
if (dir == PlayerDirection.UP && direction == PlayerDirection.DOWN ||
dir == PlayerDirection.DOWN && direction == PlayerDirection.UP ||
dir == PlayerDirection.LEFT && direction == PlayerDirection.RIGHT ||
dir == PlayerDirection.RIGHT && direction == PlayerDirection.LEFT)
{
return;
}
direction = dir;
//Debug.Log ("dir " + direction);
ForceMove();
}
private void Awake()
{
playerStatus = GetComponent <PlayerStatus>();
playerMove = GetComponent <PlayerMove>();
playerDir = GetComponent <PlayerDirection>();
anim = GetComponent <Animation>();
hudTextFollow = transform.Find("HUDText").gameObject;
bodyRenderer = body.GetComponent <Renderer>();
normalColor = bodyRenderer.material.color;
animNow = animNormalAttack;
animSkill = animIdle;
}
private void Start()
{
if (source == null)
{
source = GameObject.Find("SoundEffect").GetComponent <AudioSource>();
}
Manager = GameObject.Find("GameManager");
gManag = Manager.GetComponent <GameManager>();
SkinChoose = GameObject.Find("GameManager").GetComponent <GameManager>();
if (PlayerOneOrTwo)
{
DirPlayer = GameObject.Find("bout2").GetComponent <PlayerDirection>();
}
}
// Use this for initialization
void Start()
{
instance = this.gameObject;
direction = inicialDirection;
boneCounterText = boneCounter.GetComponent <Text> ();
mergedBoneCounterText = mergedBoneCounter.GetComponent <Text> ();
invulnerableTimeStamp = 0;
maxLife = baseStats.maxLife;
speed = baseStats.speed;
magicDamage = baseStats.initialMagicDamage;
stabDamage = baseStats.initialMeleeDamage;
meleeAttackCooldown = baseStats.meleeAttackCooldown;
rangedAttackCooldown = baseStats.rangedAttackCooldown;
currentLife = maxLife;
levelManager = GetComponent <PlayerLevelManager>();
DefineCharacterStats();
animator.runtimeAnimatorController = characterStats.animatorController;
GameObject firingPointsParent = Instantiate(characterStats.firingPointsPrefab, transform);
upFiringPoint = firingPointsParent.transform.Find("UpFiringPoint");
downFiringPoint = firingPointsParent.transform.Find("DownFiringPoint");
rightFiringPoint = firingPointsParent.transform.Find("RightFiringPoint");
upRightFiringPoint = firingPointsParent.transform.Find("UpRightFiringPoint");
downRightFiringPoint = firingPointsParent.transform.Find("DownRightFiringPoint");
if (representsPlayer == RepresentsPlayer.Player1)
{
magicProjectilePrefab = characterStats.projectilePrefab;
meleeAttackPrefab = characterStats.meleeAttackPrefab;
}
else
{
magicProjectilePrefab = characterStats.projectilePrefabPlayer2;
meleeAttackPrefab = characterStats.meleeAttackPrefabPlayer2;
}
DefineAnimationLengths();
}
//Arrow Key Movement
void Player_Option_Set_1()
{
if (Input.GetKey(KeyCode.UpArrow))
{
direction = PlayerDirection.UP;
SetAnimDirection(1.0f, true);
MoveY(playerSpeed);
}
if (Input.GetKey(KeyCode.DownArrow))
{
direction = PlayerDirection.DOWN;
SetAnimDirection(-1.0f, true);
MoveY(-playerSpeed);
}
if (Input.GetKey(KeyCode.LeftArrow))
{
direction = PlayerDirection.LEFT;
SetAnimSpeed(1.0f, false);
MoveX(-playerSpeed);
}
if (Input.GetKey(KeyCode.RightArrow))
{
direction = PlayerDirection.RIGHT;
SetAnimSpeed(-1.0f, false);
MoveX(playerSpeed);
}
if (Input.GetKeyDown(KeyCode.F))
{
}
if (Input.GetKeyDown(KeyCode.Space))
{
GetComponent <SoundEffects>().PlaySound(0);
canAttack = true;
anim.SetBool("Attack", canAttack);
}
if (Input.GetKeyUp(KeyCode.Space))
{
GetComponent <SoundEffects>().PlaySound(0);
canAttack = false;
anim.SetBool("Attack", canAttack);
}
}
private void Awake()
{
//Ensure only one instance exists
if (instance == null)
{
instance = this;
}
//Destroy other instances
else
{
Destroy(this);
}
Direction = GetComponentInChildren <PlayerDirection>();
}
public void SetInputDirection(PlayerDirection dir)
{
//prevent movement in the opposite direction
if (dir == PlayerDirection.UP && direction == PlayerDirection.DOWN ||
dir == PlayerDirection.DOWN && direction == PlayerDirection.UP ||
dir == PlayerDirection.RIGHT && direction == PlayerDirection.LEFT ||
dir == PlayerDirection.LEFT && direction == PlayerDirection.RIGHT)
{
return;//stop here
}
direction = dir;
ForceMove();
}
public void SetNewPosition(Enum newDirection)
{
switch (newDirection)
{
case PlayerDirection.Up: { playerPos.x += blockPace; _PlayerDirection = PlayerDirection.Up; gameObject.transform.localPosition = playerPos; break; }
case PlayerDirection.Down: { playerPos.x -= blockPace; _PlayerDirection = PlayerDirection.Down; gameObject.transform.localPosition = playerPos; break; }
case PlayerDirection.Left: { playerPos.z += blockPace; _PlayerDirection = PlayerDirection.Left; gameObject.transform.localPosition = playerPos; break; }
case PlayerDirection.Right: { playerPos.z -= blockPace; _PlayerDirection = PlayerDirection.Right; gameObject.transform.localPosition = playerPos; break; }
case PlayerDirection.Stay: { _PlayerDirection = PlayerDirection.Stay; break; }
}
}
/// <summary>
/// Set up a few base things, mostly other components.
/// </summary>
public void Awake()
{
SetPlayerState(PlayerState.InAirFromFall);
playerDirection = PlayerDirection.Stationary;
playerAnimation = GetComponent <PlayerAnimation>();
//Destroy client scripts if we don't own this
//Animation and movement are handled externally
if (networkView && !networkView.isMine && gameObject.name != "MenuDude")
{
Destroy(playerAnimation);
Destroy(this);
}
}
public void SetInputDirection(PlayerDirection dir)
{
// .. Prevent movement in the opposite direction
if (dir == PlayerDirection.Up && direction == PlayerDirection.Down ||
dir == PlayerDirection.Down && direction == PlayerDirection.Up ||
dir == PlayerDirection.Right && direction == PlayerDirection.Left ||
dir == PlayerDirection.Left && direction == PlayerDirection.Right)
{
return;
}
direction = dir;
ForceMove(); // Move the snake immediatly without waiting for the next movement frequency threshold
}
public override BeatPooled GetNewInstance(PlayerDirection direction)
{
var beatInstance = BeatPool.Instance.Get();
Vector2 spawnPoint = BeatUtil.GetSpawnPointFromDirection(direction);
Transform target = BeatUtil.GetTransformFromDirection(direction);
beatInstance.transform.position = spawnPoint;
var pooled = beatInstance.GetComponent <BeatPooled>();
pooled.Init(target, Name, direction);
return(beatInstance);
}
public void BuyCurrency(PlayerDirection playerDirection, Resource.CurrencyProducts currency)
{
var tradeCost = ResourcesBuyCost.GetCost(playerDirection, currency);
// Trade process
var trader = GetNeighborByDirection(playerDirection);
resources.ChangeMoney(-tradeCost);
trader.resources.EarnTempMoney(tradeCost);
resources.EarnTempProduction(new Resource.CurrencyItem {
Currency = currency, Amount = 1
});
TradeInfo.Lock(currency);
}
private void HandleDirection(Vector2 movement)
{
if (movement != Vector2.zero)
{
anim.SetBool("IsWalking", true);
}
else
{
anim.SetBool("IsWalking", false);
}
if (movement.y == 1 && movement.x == 0)
{
Direction = PlayerDirection.Up;
anim.SetInteger("Direction", 1);
return;
}
if (movement.x == 1 && movement.y == 0)
{
Vector3 temp = transform.localScale;
temp.x = 1;
transform.localScale = temp;
Direction = PlayerDirection.Right;
anim.SetInteger("Direction", 2);
return;
}
else if (movement.y == -1 && movement.x == 0)
{
Direction = PlayerDirection.Down;
anim.SetInteger("Direction", 3);
return;
}
else if (movement.x == -1 && movement.y == 0)
{
Vector3 temp = transform.localScale;
temp.x = -1;
transform.localScale = temp;
Direction = PlayerDirection.Left;
anim.SetInteger("Direction", 4);
return;
}
else
{
anim.SetInteger("Direction", 0);
}
}
void Update ()
{
if (m_bIsCollide) {
m_bIsCollide = !m_bIsCollide;
if (direction == PlayerDirection.right) {
direction = PlayerDirection.left;
} else if(direction == PlayerDirection.left) {
direction = PlayerDirection.right;
}
this.transform.localScale = new Vector3(this.transform.localScale.x * -1,
this.transform.localScale.y, this.transform.localScale.z);
}
this.transform.localPosition = new Vector3 (this.transform.localPosition.x + Time.deltaTime * Direction (),
this.transform.localPosition.y, this.transform.localPosition.z);
}
//Arrow Key Movement
void Player_Option_Set_1() {
if (Input.GetKey (KeyCode.UpArrow)) {
direction = PlayerDirection.UP;
SetAnimDirection(1.0f,true);
MoveY(playerSpeed);
}
if (Input.GetKey (KeyCode.DownArrow)) {
direction = PlayerDirection.DOWN;
SetAnimDirection(-1.0f,true);
MoveY(-playerSpeed);
}
if (Input.GetKey (KeyCode.LeftArrow)) {
direction = PlayerDirection.LEFT;
SetAnimSpeed(1.0f,false);
MoveX(-playerSpeed);
}
if (Input.GetKey (KeyCode.RightArrow)) {
direction = PlayerDirection.RIGHT;
SetAnimSpeed(-1.0f,false);
MoveX(playerSpeed);
}
if (Input.GetKeyDown (KeyCode.F)) {
}
if (Input.GetKeyDown (KeyCode.Space)) {
GetComponent<SoundEffects>().PlaySound (0);
canAttack = true;
anim.SetBool ("Attack", canAttack);
}
if (Input.GetKeyUp (KeyCode.Space)) {
GetComponent<SoundEffects>().PlaySound (0);
canAttack = false;
anim.SetBool ("Attack", canAttack);
}
}
public override void Initialize(Stage stage)
{
triggered = false;
UsingOnTriggerEnter = true;
UsingOnTriggerStay = false;
UsingOnTriggerExit = false;
rotateRight = true;
rotationTime = 1.0f;
newForwardDir = actor.Parm.GetVector3("NewDir");
newDir = Vector3ToMoveDir(newForwardDir);
if (actor.Parm.HasParm("RotateRight"))
rotateRight = actor.Parm.GetBool("RotateRight");
if (actor.Parm.HasParm("RotationTime"))
rotationTime = actor.Parm.GetFloat("RotationTime");
base.Initialize(stage);
}
public void TurnBullet(PlayerDirection pDirection)
{
if (pDirection == PlayerDirection.left)
{
direction = EnemyDirection.right;
Mirror(false, false);
}
if (pDirection == PlayerDirection.right)
{
direction = EnemyDirection.left;
Mirror(true, false);
}
if (pDirection == PlayerDirection.up)
{
direction = EnemyDirection.up;
}
if (pDirection == PlayerDirection.down)
{
direction = EnemyDirection.down;
}
}
//gethit
public void HitByBullet(float pBulletDamage, PlayerDirection pDirection)
{
SoundChannel soundChannel = new SoundChannel(2);
Sound hit = new Sound("hurt.wav");
hit.Play(false, 2);
if (_state == EnemyState.death) return;
if (_health <= 0f)
{
_state = EnemyState.death;
_level.player.addPoints((int)_points);
}
else if (_health > 0f)
{
directionHit = pDirection;
_health -= pBulletDamage;
_hitTimer = pBulletDamage;
_state = EnemyState.hit;
_level.player.addPoints(10);
}
}
//-------------------------------------------------------- Player Movement
private void TakeInputs()
{
CurrentDirection = Input.GetAxisRaw("Horizontal");
switch (Convert.ToInt16(CurrentDirection))
{
case -1:
player_Direction = PlayerDirection.Left;
break;
case 1:
player_Direction = PlayerDirection.Right;
break;
default:
break;
}
if (Input.GetKey(KeyCode.W) || Input.GetKey(KeyCode.UpArrow))
{
Jump();
}
is_Shooting = Input.GetKey(KeyCode.Space);
}
/// <summary>
/// Make a player face a direction.
/// </summary>
/// <param name="direction">Direction to face.</param>
public void Face(PlayerDirection direction)
{
switch (direction)
{
case PlayerDirection.Down:
_renderer.sprite = StandDown;
break;
case PlayerDirection.Left:
_renderer.sprite = StandLeft;
break;
case PlayerDirection.Right:
_renderer.sprite = StandRight;
break;
case PlayerDirection.Up:
_renderer.sprite = StandUp;
break;
}
}
/// <summary>
/// Set a direction for a player to move in.
/// </summary>
/// <param name="direction">Target direction.</param>
public void MoveTo(PlayerDirection direction)
{
if (Status == PlayerStatus.Walking)
return;
Direction = direction;
Status = PlayerStatus.Walking;
switch (direction)
{
case PlayerDirection.Down:
Target = Position + DIR_DOWN;
break;
case PlayerDirection.Left:
Target = Position + DIR_LEFT;
break;
case PlayerDirection.Right:
Target = Position + DIR_RIGHT;
break;
case PlayerDirection.Up:
Target = Position + DIR_UP;
break;
}
}
protected Point GetNextPlayerTile(Player player, PlayerDirection direction)
{
int tileLeft = player.TileLeft, tileTop = player.TileTop;
GetNextPlayerTile(player, direction, out tileLeft, out tileTop);
return (new Point(tileLeft, tileTop));
}
public override void Initialize(Stage stage)
{
track = 0.0f;
track = actor.PhysicsObject.Position.Z;
Space = stage.GetQB<PhysicsQB>().Space;
//input actions
ControlsQB controlsQB = stage.GetQB<ControlsQB>();
strum = controlsQB.GetInputAction("Strum");
A = controlsQB.GetInputAction("A");
B = controlsQB.GetInputAction("B");
Y = controlsQB.GetInputAction("Y");
X = controlsQB.GetInputAction("X");
leftBumper = controlsQB.GetInputAction("LeftBumper");
rightBumper = controlsQB.GetInputAction("RightBumper");
triggers = controlsQB.GetInputAction("Triggers");
leftAxisX = controlsQB.GetInputAction("MoveRight");
guitarJump = controlsQB.GetInputAction("GuitarJump");
//set move direction
//TODO: look this up in a parm
MoveDirection = PlayerDirection.Right;
//get attack list
attacks = new Engine.AttackSystem.ComboSystem("MoveList");
//set camera
CameraQB cameraQB = stage.GetQB<CameraQB>();
PlayerCamera playerCamera = new PlayerCamera(actor.PhysicsObject, CameraQB.DefaultProjectionMatrix);
playerCamera.Reset();
cameraQB.JumpToCamera(playerCamera);
//animations
playerAnimation = actor.GetAgent<PlayerAnimationAgent>();
State = PlayerState.Normal;
facing = PlayerDirection.Right;
//dashing & lock on range
if (Player.PhysicsObject.physicsType == PhysicsObject.PhysicsType.Character)
{
Player.PhysicsObject.CollisionInformation.CollisionRules.Group = PhysicsQB.playerGroup;
if (Player.Parm.HasParm("DashSpeed"))
Player.PhysicsObject.CharacterController.DashSpeed = Player.Parm.GetFloat("DashSpeed");
if (Player.Parm.HasParm("DashTime"))
Player.PhysicsObject.CharacterController.DashTime = Player.Parm.GetFloat("DashTime");
}
//combat
input = new ButtonInput();
smash = 0;
//support for the flow mechanic
flow = new Flow();
//Load the player sounds here
AudioQB AQB = Stage.ActiveStage.GetQB<AudioQB>();
int index = 0;
while (Player.Parm.HasParm("Sound" + index))
{
AQB.AddSound(Player.Parm.GetString("Sound" + index));
index++;
}
if(!Stage.Editor)
isStrumMode = Stage.SaveGame.getStrumMode();
}
public void Move(PlayerDirection direction)
{
}
public void HandleInput(SGDE.Game game, InputComponent input)
{
SGDE.Input.Keyboard keyboard = (SGDE.Input.Keyboard)input;
if (!staggered)
{
if (keyboard.IsKeyPressed(Keys.Left))
{
this.Translate(-5, 0);
if (dir != PlayerDirection.Left)
{
if (!knockBack)
this.SpriteImage.SetAnimation("WalkLeft");
else
this.SpriteImage.SetAnimation("KnockBackLeft");
dir = PlayerDirection.Left;
}
}
else if (keyboard.IsKeyPressed(Keys.Right))
{
this.Translate(5, 0);
if (dir != PlayerDirection.Right)
{
if (!knockBack)
this.SpriteImage.SetAnimation("WalkRight");
else
this.SpriteImage.SetAnimation("KnockBackRight");
dir = PlayerDirection.Right;
}
}
else
{
this.SetVelocity(0, this.GetVelocity().Y);
switch (dir)
{
case PlayerDirection.Right:
if (!knockBack)
this.SpriteImage.SetAnimation("StandRight");
else
this.SpriteImage.SetAnimation("KnockBackRight");
dir = PlayerDirection.StandingRight;
break;
case PlayerDirection.Left:
if (!knockBack)
this.SpriteImage.SetAnimation("StandLeft");
else
this.SpriteImage.SetAnimation("KnockBackLeft");
dir = PlayerDirection.StandingLeft;
break;
}
}
if (keyboard.IsKeyPressed(Keys.Up))
{
if (onGround && this.GetCollisionUnit().HasCollisions())
{
this.SetVelocity(this.GetVelocity().X, -10.0f);
onGround = false;
}
}
if (keyboard.IsKeyPressed(Keys.Z) && Game1.superJumpActive)
{
if (onGround && this.GetCollisionUnit().HasCollisions())
{
this.SetVelocity(this.GetVelocity().X, -13.0f);
onGround = false;
}
}
}
if (keyboard.IsKeyPressed(Keys.Escape))
game.Exit();
}
public void Dash(int dir)
{
State = PlayerState.Dashing;
recoveryTimer = Player.PhysicsObject.CharacterController.DashTime;
flow.DoingAttack(recoveryTimer, false);
//play dashing sound
Stage.ActiveStage.GetQB<AudioQB>().PlaySound("Dash_16", 1.0f, 0.0f, 0.0f);
Vector2 dashDirection = Vector2.Zero;
if (dir == 0) //dash in the direction we are facing
{
switch (facing)
{
case PlayerDirection.Right:
dashDirection = Vector2.UnitX;
break;
case PlayerDirection.Left:
dashDirection = -Vector2.UnitX;
break;
case PlayerDirection.Forward:
dashDirection = -Vector2.UnitY;
break;
case PlayerDirection.Backward:
dashDirection = Vector2.UnitY;
break;
}
}
else //go whichever direction we were given
{
switch (MoveDirection)
{
case PlayerDirection.Right:
dashDirection = dir * Vector2.UnitX;
facing = (dir > 0) ? PlayerDirection.Right : PlayerDirection.Left;
break;
case PlayerDirection.Left:
dashDirection = -dir * Vector2.UnitX;
facing = (dir > 0) ? PlayerDirection.Left : PlayerDirection.Right;
break;
case PlayerDirection.Forward:
dashDirection = -dir * Vector2.UnitY;
facing = (dir > 0) ? PlayerDirection.Forward : PlayerDirection.Backward;
break;
case PlayerDirection.Backward:
dashDirection = dir * Vector2.UnitY;
facing = (dir > 0) ? PlayerDirection.Backward : PlayerDirection.Forward;
break;
}
}
actor.PhysicsObject.CharacterController.Dash(dashDirection);
}
private void recoil(PlayerDirection pDirection)
{
//Jump
if (pDirection == PlayerDirection.down)
{
_velocityY = _jumpSpeed;
_inAir = true;
}
//Recoil
if (_inAir)
{
if (pDirection == PlayerDirection.left) { _velocityX = _pushBackSpeed * 3; }
else if (pDirection == PlayerDirection.right) { _velocityX = -_pushBackSpeed * 3; }
else if (pDirection == PlayerDirection.up) { _velocityY = -_jumpSpeed; }
}
else if (!_inAir)
{
_recoil = true;
if (pDirection == PlayerDirection.left) { _velocityX = _pushBackSpeed * 3; }
else if (pDirection == PlayerDirection.right) { _velocityX = -_pushBackSpeed * 3; }
}
}
protected void GetNextPlayerTile(Player player, PlayerDirection direction,
out int tileLeft, out int tileTop)
{
tileLeft = player.TileLeft;
tileTop = player.TileTop;
if (player.Team.WrappedMovement)
{
switch (direction)
{
case PlayerDirection.Up:
tileTop = (player.TileTop == 0) ? Settings.Tiles - 1 : player.TileTop - 1;
break;
case PlayerDirection.UpRight:
tileLeft = (player.TileLeft == (Settings.Tiles - 1)) ? 0 : player.TileLeft + 1;
tileTop = (player.TileTop == 0) ? Settings.Tiles - 1 : player.TileTop - 1;
break;
case PlayerDirection.Right:
tileLeft = (player.TileLeft == (Settings.Tiles - 1)) ? 0 : player.TileLeft + 1;
break;
case PlayerDirection.DownRight:
tileLeft = (player.TileLeft == (Settings.Tiles - 1)) ? 0 : player.TileLeft + 1;
tileTop = (player.TileTop == (Settings.Tiles - 1)) ? 0 : player.TileTop + 1;
break;
case PlayerDirection.Down:
tileTop = (player.TileTop == (Settings.Tiles - 1)) ? 0 : player.TileTop + 1;
break;
case PlayerDirection.DownLeft:
tileLeft = (player.TileLeft == 0) ? Settings.Tiles - 1 : player.TileLeft - 1;
tileTop = (player.TileTop == (Settings.Tiles - 1)) ? 0 : player.TileTop + 1;
break;
case PlayerDirection.Left:
tileLeft = (player.TileLeft == 0) ? Settings.Tiles - 1 : player.TileLeft - 1;
break;
case PlayerDirection.UpLeft:
tileLeft = (player.TileLeft == 0) ? Settings.Tiles - 1 : player.TileLeft - 1;
tileTop = (player.TileTop == 0) ? Settings.Tiles - 1 : player.TileTop - 1;
break;
}
} // if wrap world
else
{
switch (direction)
{
case PlayerDirection.Up:
tileTop = Math.Max(0, player.TileTop - 1);
break;
case PlayerDirection.UpRight:
tileLeft = Math.Min(Settings.Tiles - 1, player.TileLeft + 1);
tileTop = Math.Max(0, player.TileTop - 1);
break;
case PlayerDirection.Right:
tileLeft = Math.Min(Settings.Tiles - 1, player.TileLeft + 1);
break;
case PlayerDirection.DownRight:
tileLeft = Math.Min(Settings.Tiles - 1, player.TileLeft + 1);
tileTop = Math.Min(Settings.Tiles - 1, player.TileTop + 1);
break;
case PlayerDirection.Down:
tileTop = Math.Min(Settings.Tiles - 1, player.TileTop + 1);
break;
case PlayerDirection.DownLeft:
tileLeft = Math.Max(0, player.TileLeft - 1);
tileTop = Math.Min(Settings.Tiles - 1, player.TileTop + 1);
break;
case PlayerDirection.Left:
tileLeft = Math.Max(0, player.TileLeft - 1);
break;
case PlayerDirection.UpLeft:
tileLeft = Math.Max(0, player.TileLeft - 1);
tileTop = Math.Max(0, player.TileTop - 1);
break;
}
}
}
private void SetFacingDirection(int dir)
{
switch (MoveDirection)
{
case PlayerDirection.Right:
if (dir > 0.0f)
facing = PlayerDirection.Right;
else if (dir < 0.0f)
facing = PlayerDirection.Left;
break;
case PlayerDirection.Left:
if (dir > 0.0f)
facing = PlayerDirection.Left;
else if (dir < 0.0f)
facing = PlayerDirection.Right;
break;
case PlayerDirection.Forward:
if (dir > 0.0f)
facing = PlayerDirection.Forward;
else if (dir < 0.0f)
facing = PlayerDirection.Backward;
break;
case PlayerDirection.Backward:
if (dir > 0.0f)
facing = PlayerDirection.Backward;
else if (dir < 0.0f)
facing = PlayerDirection.Forward;
break;
}
}
public void PerformAttack(Vector3 position, PlayerDirection facing, Move newMove, float increase)
{
bool enemyHit = false;
bool shieldHit = false;
string soundName = null;
if (newMove.Sound_hit != String.Empty)
soundName = newMove.Sound_hit;
float damage = newMove.Damage + newMove.Damage * increase;
float rockMeter = newMove.RockMeterIncrease;
//bouding box
const float DEPTH_CONST = 100;
const float HEIGHT_CONST = 2;
BoundingBox hitbox = new BoundingBox();
float front = newMove.FrontArea + newMove.FrontArea * increase;
float back = newMove.BackArea + newMove.BackArea * increase;
hitbox.Min.Y = position.Y - HEIGHT_CONST - HEIGHT_CONST * increase;
hitbox.Max.Y = position.Y + HEIGHT_CONST + HEIGHT_CONST * increase;
Vector3 force = Vector3.Zero;
switch (facing)
{
case PlayerDirection.Right:
hitbox.Min.X = position.X - back;
hitbox.Max.X = position.X + front;
hitbox.Min.Z = position.Z - DEPTH_CONST;
hitbox.Max.Z = position.Z + DEPTH_CONST;
force = Vector3.Right;
break;
case PlayerDirection.Left:
hitbox.Min.X = position.X - front;
hitbox.Max.X = position.X + back;
hitbox.Min.Z = position.Z - DEPTH_CONST;
hitbox.Max.Z = position.Z + DEPTH_CONST;
force = Vector3.Right;
break;
case PlayerDirection.Forward:
hitbox.Min.X = position.X - DEPTH_CONST;
hitbox.Max.X = position.X + DEPTH_CONST;
hitbox.Min.Z = position.Z - front;
hitbox.Max.Z = position.Z + back;
force = Vector3.Backward;
break;
case PlayerDirection.Backward:
hitbox.Min.X = position.X - DEPTH_CONST;
hitbox.Max.X = position.X + DEPTH_CONST;
hitbox.Min.Z = position.Z - back;
hitbox.Max.Z = position.Z + front;
force = Vector3.Backward;
break;
}
// todo: move to a better place. maybe a function in player agent called "SmashEffects" or something like that. maybe a class called "PlayerAttackEffects" and a static function called "Smash" in there
if (newMove.Name == "Smash")
{
Vector3 difference = hitbox.Max - hitbox.Min;
float length = difference.Z;
float height = difference.Y;
float width = difference.X;
Vector3 center = new Vector3(hitbox.Max.X - width / 2.0f, hitbox.Max.Y - height / 2.0f, hitbox.Max.Z - length / 2.0f);
Stage.ActiveStage.GetQB<Engine.Decals.DecalQB>().CreateDecal(new Ray(center, Vector3.Down), 10.0f, "Decals/crack", 10.0f, 20.0f, Decals.DecalLayers.CracksLayer);
Stage.ActiveStage.GetQB<Particles.ParticleQB>().AddParticleEmitter(null, mainCharacter.PhysicsObject.Position + new Vector3(0.0f, -3.0f, 0.0f), true, -1f, 50,
75, 1.0f, 1.5f, 4, 5, new Vector2(1.0f), new Vector2(2.0f), new Vector3(1.0f, 0.0f, 1.0f),
Vector3.Up, new Vector3(8.4f, 0.3f, 8.4f), "dust2");
Stage.ActiveStage.GetQB<AudioQB>().PlaySound("WeakAOE_16", 1.0f, 0.0f, 0.0f);
Stage.ActiveStage.GetQB<AudioQB>().PlaySound("asphaltsmash_16", 0.7f, 0.0f, 0.0f);
}
Actor actor;
foreach (GameLib.Engine.AI.AI ai in Stage.ActiveStage.GetQB<GameLib.Engine.AI.AIQB>().aliveEnemies)
{
actor = ai.actor;
if (hitbox.Intersects(actor.PhysicsObject.CollisionInformation.BoundingBox))
{
enemyHit = true;
Vector3 actorPos = actor.PhysicsObject.Position;
HealthAgent actorHealth = actor.GetAgent<HealthAgent>();
float startingHealth = actorHealth.Health;
float remainingHealth = actorHealth.ModifyHealth(-damage, mainCharacter.PhysicsObject.Position, newMove.Disarming);
if (remainingHealth < startingHealth)
{
if (newMove.Force != Vector2.Zero && remainingHealth > 0)
{
force *= (actorPos - position);
force.Normalize();
force.X *= newMove.Force.X + newMove.Force.X * increase;
force.X *= newMove.Force.X + newMove.Force.X * increase;
float jumpVal = newMove.Force.Y + newMove.Force.Y * increase;
if (actor.PhysicsObject.physicsType == PhysicsObject.PhysicsType.CylinderCharacter)
{
actor.PhysicsObject.CylinderCharController.Body.LinearVelocity = Vector3.Zero;
if (jumpVal != 0)
{
actor.PhysicsObject.CylinderCharController.Jump(jumpVal / actor.PhysicsObject.CylinderCharController.Body.Mass);
}
if (force != Vector3.Zero)
actor.PhysicsObject.CylinderCharController.Body.ApplyLinearImpulse(ref force);
}
}
//we did damage so increase the multiplier
playerRockMeter.PerformedAttack(rockMeter);
//stun the enemy
if (newMove.StunTime != 0.0f)
ai.Stun(newMove.StunTime);
if (ai.bloodOnDamage)
{
Vector3 bloodDir = actorPos - mainCharacter.PhysicsObject.Position;
bloodDir.Normalize();
bloodDir *= 10;
Stage.ActiveStage.GetQB<Particles.ParticleQB>().AddParticleEmitter(null, actor.PhysicsObject.Position, true, -1, 5,
10, .25f, .5f, 0, 0, Vector2.One, Vector2.One * 2.0f,
Vector3.Zero, bloodDir, 2 * Vector3.One, "blood1");
Stage.ActiveStage.GetQB<Gameplay.BloodSplatterQB>().SplatBlood();
Stage.ActiveStage.GetQB<Decals.DecalQB>().CreateDecal(actorPos, new BoundingBox(new Vector3(-20.0f, -20.0f, -20.0f), new Vector3(20.0f, 20.0f, 20.0f)), "Decals/blood", 10.0f, 5.0f, Decals.DecalLayers.BloodLayer);
//Stage.ActiveStage.GetQB<Decals.DecalQB>().CreateDecal(new Ray(actor.PhysicsObject.Position, Vector3.Down), 10.0f, "Decals/blood", 10.0f, 5.0f, Decals.DecalLayers.BloodLayer);
}
if (remainingHealth <= 0.0f) //killed the enemy
{
//playerRockMeter.IncreaseRockLevel(ai.rockLevelForKilling);
int increaseRockMeter = playerRockMeter.IncreaseScoreDueToKill(ai.pointsForKilling);
playerRockMeter.AddKill();
Vector3 screenPos = Stage.renderer.GraphicsDevice.Viewport.Project(actorPos,
CameraQB.ProjectionMatrix, CameraQB.ViewMatrix, Matrix.Identity);
Stage.ActiveStage.GetQB<ParticleQB>().AddFloatingText(new Vector2(screenPos.X, screenPos.Y + 10), -50 * Vector2.UnitY,
2.0f, increaseRockMeter.ToString(System.Globalization.CultureInfo.InvariantCulture));
}
}
else //you hit an enemy but dealt no damage
{
shieldHit = true;
soundName = newMove.Sound_shield;
}
if (!newMove.AOE)
break; //only hit one enemy
}
}
//play sounds
if (shieldHit)
playRandomShieldHitSound(newMove.Disarming);
else if (!enemyHit)
playMissSound();
else
playRandomHitSound();
}
void RegularAttack() {
/*Handles the use of regular attacks*/
if (Input.GetKeyDown (KeyCode.UpArrow)) {
ChangeDirection(0);
displays.UseMagic (10);
player_direction = PlayerDirection.UP;
magicTimer = resetMagicTimer;
} else if (Input.GetKeyDown (KeyCode.DownArrow)) {
player_direction = PlayerDirection.DOWN;
ChangeDirection(1);
displays.UseMagic (10);
magicTimer = resetMagicTimer;
} else if (Input.GetKeyDown (KeyCode.LeftArrow)) {
player_direction = PlayerDirection.LEFT;
ChangeDirection(3);
displays.UseMagic (10);
magicTimer = resetMagicTimer;
} else if (Input.GetKeyDown (KeyCode.RightArrow)) {
player_direction = PlayerDirection.RIGHT;
ChangeDirection(2);
displays.UseMagic (10);
magicTimer = resetMagicTimer;
}
SetDirection ();
magicTimer -= 0.05f;
if (magicTimer <= 0) {
displays.RestoreMagic (10);
magicTimer = resetMagicTimer;
}
}
void ReadInput()
{
xAxis = Input.GetAxis("Horizontal");
yAxis = Input.GetAxis("Vertical");
//Movimiento en X
if (xAxis != 0 && yAxis == 0) {
direction = PlayerDirection.isOnX;
playerAnimator.SetBool ("isMoveSide", true);
if (xAxis > 0) {
desiredOrientation += Vector3.right;
transform.localScale = new Vector3(1, 1, 1);
} else {
desiredOrientation += Vector3.left;
transform.localScale = new Vector3(-1, 1, 1);
}
} else {
playerAnimator.SetBool ("isMoveSide", false);
}
//Moviemiento en Y
if (yAxis != 0 && xAxis == 0) {
direction = PlayerDirection.isOnY;
transform.localScale = new Vector3 (1, 1, 1);
if (yAxis > 0) {
desiredOrientation += Vector3.up;
playerAnimator.SetBool ("isMoveUp", true);
viewDirection = PlayerViewDirection.isViewUp;
} else {
desiredOrientation += Vector3.down;
playerAnimator.SetBool ("isMoveDown", true);
viewDirection = PlayerViewDirection.isViewDown;
}
} else {
playerAnimator.SetBool ("isMoveUp", false);
playerAnimator.SetBool ("isMoveDown", false);
}
//Movimiento en diagonal.
if (xAxis != 0 && yAxis != 0) {
desiredOrientation += new Vector3(xAxis, yAxis, 0);
if (direction == PlayerDirection.isOnX) {
playerAnimator.SetBool ("isMoveSide", true);
if (xAxis > 0) {
transform.localScale = new Vector3(1, 1, 1);
} else {
transform.localScale = new Vector3(-1, 1, 1);
}
} else {
if (yAxis > 0) {
playerAnimator.SetBool ("isMoveUp", true);
viewDirection = PlayerViewDirection.isViewUp;
} else {
playerAnimator.SetBool ("isMoveDown", true);
viewDirection = PlayerViewDirection.isViewDown;
}
}
}
desiredOrientation.Normalize();
}
protected int GetNextPlayerTileIndex(Player player, PlayerDirection direction)
{
int tileLeft = player.TileLeft, tileTop = player.TileTop;
GetNextPlayerTile(player, direction, out tileLeft, out tileTop);
return (ToTileIndex(tileLeft, tileTop));
}
//-------------MOVEMENT-----------------
private void getInput()
{
//------------------LEFT------------------
if (Input.GetKey((int)PlayerButtons.left))
{
_aimDirection = PlayerDirection.left;
if (!_inAir && !_recoil)
{
//Set directions
_currentAnimState = AnimationStatePlayer.walk;
//Move
_velocityX = -_walkSpeed;
}
Mirror(true, false);
}
//------------------RIGHT-----------------
else if (Input.GetKey((int)PlayerButtons.right))
{
_aimDirection = PlayerDirection.right;
if (!_inAir && !_recoil)
{
//Set directions
_currentAnimState = AnimationStatePlayer.walk;
//Move
_velocityX = _walkSpeed;
}
Mirror(false, false);
}
//-------------------UP-------------------
else if (Input.GetKey((int)PlayerButtons.up) && !_recoil)
{
//Set directions
_aimDirection = PlayerDirection.up;
}
//------------------DOWN------------------
else if (Input.GetKey((int)PlayerButtons.down) && !_recoil)
{
//Set directions
_aimDirection = PlayerDirection.down;
}
//----------------NO BUTTONS--------------
if (_recoil)
{
_currentAnimState = AnimationStatePlayer.recoil;
if (_velocityX > 0) { _velocityX -= 0.5f; }
else if (_velocityX < 0) { _velocityX += 0.5f; }
}
else if (!Input.GetKey((int)PlayerButtons.left) && !Input.GetKey((int)PlayerButtons.right))
{
if (!_inAir) { _velocityX = 0.0f; }
}
//------------------SHOOT-----------------
if (Input.GetKeyDown((int)PlayerButtons.shoot) && hasWeapon && bulletCounter >= 1)
{
shootBullet();
bulletCounter -= 1.0f;
}
//Keep velocity at his max
if (_velocityY > maxVelocityY) { _velocityY = maxVelocityY; }
//Update animstate
if (_velocityX == 0.0f) { _currentAnimState = AnimationStatePlayer.idle; }
if (_inAir == true) { _currentAnimState = AnimationStatePlayer.jump; }
}
public void EnemyAttack(float dmg, float force, Vector3 v, Actor attacker, PlayerDirection facing)
{
PlayerState state = mainCharacter.GetAgent<PlayerAgent>().State;
if (!(state == PlayerState.Jumping || state == PlayerState.Dashing))
{
BoundingBox hitbox = attacker.PhysicsObject.CollisionInformation.BoundingBox;
const float DEPTH_CONST = 100;
Vector3 position = attacker.PhysicsObject.Position;
//set the Y/height values
hitbox.Min.Y = position.Y - v.Z;
hitbox.Max.Y = position.Y + v.Z;
switch (facing)
{
case PlayerDirection.Right:
hitbox.Min.X = position.X - v.Y;
hitbox.Max.X = position.X + v.X;
hitbox.Min.Z = position.Z - DEPTH_CONST;
hitbox.Max.Z = position.Z + DEPTH_CONST;
break;
case PlayerDirection.Left:
hitbox.Min.X = position.X - v.X;
hitbox.Max.X = position.X + v.Y;
hitbox.Min.Z = position.Z - DEPTH_CONST;
hitbox.Max.Z = position.Z + DEPTH_CONST;
break;
case PlayerDirection.Forward:
hitbox.Min.X = position.X - DEPTH_CONST;
hitbox.Max.X = position.X + DEPTH_CONST;
hitbox.Min.Z = position.Z - v.Y;
hitbox.Max.Z = position.Z + v.X;
break;
case PlayerDirection.Backward:
hitbox.Min.X = position.X - DEPTH_CONST;
hitbox.Max.X = position.X + DEPTH_CONST;
hitbox.Min.Z = position.Z - v.X;
hitbox.Max.Z = position.Z + v.Y;
break;
}
//to-do get a more accurate contact point
if (hitbox.Intersects(mainCharacter.PhysicsObject.CollisionInformation.BoundingBox))
{
if (force != 0)
{
Vector3 ForceVec = Vector3.Zero;
switch (AI.AIQB.MoveDirection)
{
case PlayerDirection.Left:
goto case PlayerDirection.Right;
case PlayerDirection.Right:
if (mainCharacter.PhysicsObject.Position.X > attacker.PhysicsObject.Position.X)
ForceVec.X = force;
else
ForceVec.X = -force;
break;
case PlayerDirection.Backward:
goto case PlayerDirection.Forward;
case PlayerDirection.Forward:
if (mainCharacter.PhysicsObject.Position.Z > attacker.PhysicsObject.Position.Z)
ForceVec.Z = force;
else
ForceVec.Z = -force;
break;
}
mainCharacter.PhysicsObject.CharacterController.Body.ApplyLinearImpulse(ref ForceVec);
}
Vector3 bloodDir = mainCharacter.PhysicsObject.Position - attacker.PhysicsObject.Position;
bloodDir.Normalize();
bloodDir *= 10;
Stage.ActiveStage.GetQB<Particles.ParticleQB>().AddParticleEmitter(null, mainCharacter.PhysicsObject.Position, true, -1, 5,
10, .25f, .5f, 0, 0, Vector2.One, Vector2.One * 2.0f, Vector3.Zero,
bloodDir, 2 * Vector3.One, "blood1");
Stage.ActiveStage.GetQB<Gameplay.BloodSplatterQB>().SplatBlood();
Stage.ActiveStage.GetQB<Decals.DecalQB>().CreateDecal(mainCharacter.PhysicsObject.Position, new BoundingBox(new Vector3(-20.0f, -20.0f, -20.0f), new Vector3(20.0f, 20.0f, 20.0f)), "Decals/blood", 10.0f, 5.0f, Decals.DecalLayers.BloodLayer);
//Stage.ActiveStage.GetQB<Decals.DecalQB>().CreateDecal(new Ray(mainCharacter.PhysicsObject.Position, Vector3.Down), 10.0f, "Decals/blood", 10.0f, 5.0f, Decals.DecalLayers.BloodLayer);
playerRockMeter.RockLevelDownDueToDamage(dmg);
//play a random take damage sound
playRandomTakeDamageSound();
}
}
else
{
return;
}
}
public void ChangeMoveDirection(PlayerDirection newDirection, bool rotateRight, float timeForRotation)
{
CameraQB cameraQB = Stage.ActiveStage.GetQB<CameraQB>();
stun(timeForRotation);
switch (newDirection)
{
case PlayerDirection.Left:
(cameraQB.ActiveCamera as PlayerCamera).DesiredPositionOffset = new Vector3(0.0f, 3.0f, -20.0f);
track = actor.PhysicsObject.Position.Z;
break;
case PlayerDirection.Right:
(cameraQB.ActiveCamera as PlayerCamera).DesiredPositionOffset = new Vector3(0.0f, 3.0f, 20.0f);
track = actor.PhysicsObject.Position.Z;
break;
case PlayerDirection.Forward:
(cameraQB.ActiveCamera as PlayerCamera).DesiredPositionOffset = new Vector3(20.0f, 3.0f, 0.0f);
track = actor.PhysicsObject.Position.X;
break;
case PlayerDirection.Backward:
(cameraQB.ActiveCamera as PlayerCamera).DesiredPositionOffset = new Vector3(-20.0f, 3.0f, 0.0f);
track = actor.PhysicsObject.Position.X;
break;
case PlayerDirection.Up:
(cameraQB.ActiveCamera as PlayerCamera).DesiredPositionOffset = new Vector3(0.0f, 3.0f, -20.0f);
break;
case PlayerDirection.Down:
(cameraQB.ActiveCamera as PlayerCamera).DesiredPositionOffset = new Vector3(0.0f, 3.0f, 20.0f);
break;
}
MoveDirection = newDirection;
facing = MoveDirection;
}
