public override AbilityStateDelta PollInput(AbilityInput input)
{
AbilityStateDelta delta = AbilityStateDelta.None;
CacheInput(input);
if (HasPersistentObjects)
{
UpdatePersistentObjects(input);
}
else if (Ability.currentAmmo > 0)
{
if (Ability.Behaviour.ShouldFire(input))
{
Fire(input);
delta |= AbilityStateDelta.Fired;
}
}
if (HasPersistentObjects)
{
delta |= AbilityStateDelta.HasPersistentObject;
}
return(delta);
}
public void InvokeAbility(AbilityInput abilityInput)
{
//Do different things depending on the if this was pressed, held or released.
switch (abilityInput)
{
default:
{
Debug.LogError("The ability input has not been given correctly.");
return;
}
case AbilityInput.Down:
{
AbilityDown();
return;
}
case AbilityInput.Hold:
{
AbilityHold();
return;
}
case AbilityInput.Up:
{
AbilityUp();
return;
}
}
}
private void CreateProjectiles(float angleToTarget, AbilityInput input)
{
foreach (Muzzle muzzle in Ability.Behaviour.Muzzles)
{
IAbilityObject abilityObject = muzzle.Spawner.Spawn(Ability, muzzle.Multiplier);
abilityObject.GameObject.transform.position = Ability.Owner.transform.position;
float angle = GetAngle(muzzle, angleToTarget);
Vector2 direction = angle.GetDirection();
if (Ability.Behaviour.UseOrthographicScaling)
{
direction = Utility.ScaleToOrthographicVector(direction);
}
if (abilityObject is ISetTargetDirection directionSetter)
{
directionSetter.SetTargetDirection(direction);
}
if (abilityObject is ISetTargetPosition positionSetter)
{
positionSetter.SetTargetPosition(input.TargetPosition);
}
if (abilityObject is IPersistentAbilityObject persistentObject)
{
PersistentObjects.Add(persistentObject);
}
}
}
public AbilityResponse(AbilityInput ability, Vector3 startPosition)
{
_id = ability.GetId();
_type = ability.GetAbilityType();
_startPosition = new PositionInfo(startPosition);
_targetPosition = new PositionInfo(ability.GetTargetPosition());
}
protected AbilityInput GetDefaultInput(Vector2 targetPosition)
{
AbilityInput input = GetDefaultInput();
input.TargetPosition = targetPosition;
return(input);
}
public AbilityActor(Ability ability, Transform casterTransform)
{
this.ability = ability;
m_radius = ability.GetCastRange();
m_casterTransform = casterTransform;
// 解析技能指示器
m_abilityInput = CreateAbilityInput(ability);
}
public void Charge(AbilityInput input)
{
if (CurrentCharge == 0)
{
Effects.StartChargeEffects();
}
CurrentCharge = Mathf.Clamp(CurrentCharge + Time.deltaTime, 0, ChargeTime);
}
public override AbilityStateDelta PollInput(AbilityInput input)
{
if (input.ShouldReload && !IsReloading)
{
StartReload();
return(AbilityStateDelta.Reloading);
}
return(AbilityStateDelta.None);
}
protected override void HandlePacket(Packet packet)
{
BitBuffer bitBuffer = new BitBuffer();
bitBuffer.PutBytes(packet.getData());
bitBuffer.Flip();
PlayerInput input = PlayerInput.fromBytes(bitBuffer);
switch (input.GetInputType())
{
case InputType.MOVEMENT:
_players[input.GetId()].SetTargetPosition(((MovementInput)input).GetPosition());
break;
case InputType.ABILITY:
AbilityInput ability = (AbilityInput)input;
Vector3 abilityStartPosition = Vector3.zero;
switch (ability.GetAbilityType())
{
case AbilityType.AUTOATTACK:
abilityStartPosition = _players[ability.GetId()].transform.position;
AutoAttack autoAttack = SpawnAutoAttack(ability.GetId(), abilityStartPosition, ability.GetTargetPosition());
_lastAbilityId = (_lastAbilityId + 1) % 255;
_autoAttacks.Add(_lastAbilityId, autoAttack);
break;
case AbilityType.FREEZE:
_players[ability.GetId()].SpawnFreeze(ability.GetTargetPosition());
break;
case AbilityType.FLASH:
_players[ability.GetId()].MoveTo(ability.GetTargetPosition());
_players[ability.GetId()].CancelMovement();
break;
case AbilityType.EXPLOSION:
CreateExplosion(ability.GetTargetPosition());
break;
}
_channel.SendAll(new AbilityResponse(ability, abilityStartPosition), true);
break;
case InputType.START_GAME:
_lastPlayerId++;
Vector3 startPosition = new Vector3(2f, 1.2f, 0f);
Player player = CreateServerPlayer(new PlayerInfo(_lastPlayerId, startPosition));
_players.Add(_lastPlayerId, player);
_channel.Send(new PlayerInfoBroadcast(_lastPlayerId, _players), packet.getAddress(), true);
PlayerInfo playerInfo = new PlayerInfo(_lastPlayerId, player.GetHealth(), new PositionInfo(startPosition));
_channel.SendAllExcluding(new NewPlayerEvent(playerInfo), packet.getAddress(), true);
break;
}
packet = _channel.GetPacket();
bitBuffer.Clear();
}
public override bool ShouldFire(AbilityInput input)
{
if (singleFire)
{
return(ShouldFireSingle(input));
}
else
{
return(ShouldFireContinuous(input));
}
}
private void Fire(AbilityInput input)
{
LastFireTime = Time.time;
Ability.CurrentAmmo--;
Vector2 delta = (TargetPosition - (Vector2)Ability.Owner.transform.position).normalized;
float angleToTarget = Mathf.Atan2(delta.y, delta.x) * Mathf.Rad2Deg;
CreateProjectiles(angleToTarget, input);
Ability.OnFired();
}
private void Update()
{
if (InputSuppressor.IsSuppressed || PauseState.IsPaused)
{
return;
}
AbilityInput input = GetInput();
DebugInput(input);
currentAbility.Value.UpdateState(input);
}
public AbilityStateDelta UpdateState(AbilityInput input)
{
AbilityStateDelta delta = AbilityStateDelta.None;
delta |= Reloader.PollInput(input);
if (Reloader.IsReloading)
{
delta |= Reloader.DoReload();
}
else
{
delta |= Activator.PollInput(input);
}
return(delta);
}
public static PlayerInput fromBytes(BitBuffer bitBuffer)
{
int id = bitBuffer.GetByte();
InputType type = (InputType)bitBuffer.GetByte();
switch (type)
{
case InputType.MOVEMENT:
return(MovementInput.FromBytes(id, bitBuffer));
case InputType.ABILITY:
return(AbilityInput.FromBytes(id, bitBuffer));
case InputType.START_GAME:
return(GameStartInput.FromBytes(id, bitBuffer));
}
return(null);
}
private void UpdatePersistentObjects(AbilityInput input)
{
for (int i = PersistentObjects.Count - 1; i >= 0; i--)
{
Vector2 direction = TargetPosition - (Vector2)Ability.Owner.transform.position;
if (PersistentObjects[i] is ISetTargetDirection directionSetter)
{
directionSetter.SetTargetDirection(direction);
}
if (PersistentObjects[i] is ISetTargetPosition positionSetter)
{
positionSetter.SetTargetPosition(Ability.Owner.transform.position);
}
if (PersistentObjects[i].ShouldBeDestroyed())
{
PersistentObjects.RemoveAt(i);
}
}
}
private bool ShouldFireContinuous(AbilityInput input)
{
if (input.FireButtonStay)
{
UpdateChargeEffect(input);
if (CurrentCharge >= ChargeTime)
{
return(base.ShouldFire(input));
}
else
{
Charge(input);
}
}
else
{
RemoveCharge();
}
return(false);
}
private bool ShouldFireSingle(AbilityInput input)
{
if (IsCooldownReady)
{
if (CurrentCharge >= ChargeTime)
{
UpdateChargeEffect(input);
return(input.FireButtonReleased);
}
else if (input.FireButtonStay)
{
UpdateChargeEffect(input);
Charge(input);
}
else
{
CurrentCharge = 0;
}
}
return(false);
}
protected override AbilityStateDelta UseAbility()
{
AbilityInput input = GetDefaultInput(TargetPosition);
return(Ability.UpdateState(input));
}
public abstract AbilityStateDelta PollInput(AbilityInput input);
private void CacheInput(AbilityInput input)
{
TargetPosition = input.TargetPosition;
}
// Update is called once per frame
public override void Update()
{
// if not local player, ignore an controller inputs!!!!
if (!isLocalPlayer)
{
return;
}
shipInputs = new ShipInputs();
// check for controller assignment to the player
if (!inputIsAttached)
{
// check for an available device
foreach (InputDevice device in InputManager.Devices)
{
if (device.Action1.WasPressed && !devicesInUse.Contains(device))
{
SetInput(device);
break;
}
}
}
// if you have an attached controller
if (inputIsAttached)
{
// get inputs from the controller and save them
shipInputs.warp.isPressed = actions.warp.IsPressed;
shipInputs.boost.isPressed = actions.boost.IsPressed;
shipInputs.special.isPressed = actions.special.IsPressed;
shipInputs.flipShot.isPressed = actions.flipShot.IsPressed;
shipInputs.start.isPressed = actions.start.IsPressed;
shipInputs.warp.wasPressed = actions.warp.WasPressed;
shipInputs.boost.wasPressed = actions.boost.WasPressed;
shipInputs.special.wasPressed = actions.special.WasPressed;
shipInputs.flipShot.wasPressed = actions.flipShot.WasPressed;
shipInputs.start.wasPressed = actions.start.WasPressed;
shipInputs.warp.wasReleased = actions.warp.WasReleased;
shipInputs.boost.wasReleased = actions.boost.WasReleased;
shipInputs.special.wasReleased = actions.special.WasReleased;
shipInputs.flipShot.wasReleased = actions.flipShot.WasReleased;
shipInputs.start.wasReleased = actions.start.WasReleased;
float grindVal = actions.grind.Value;
if (grindVal < GRIND_RELEASE_VAL)
{
shipInputs.grind.wasReleased = true;
shipInputs.grind.isPressed = shipInputs.grind.wasPressed = false;
}
else
{
shipInputs.grind.wasPressed = !shipInputs.grind.isPressed ? true : false;
shipInputs.grind.isPressed = true;
}
shipInputs.direction.x = actions.movement.X;
shipInputs.direction.y = actions.movement.Y;
// send movement inputs to the server
CmdUploadMovementInput(shipInputs.direction);
// send ability inputs to the server
AbilityInput abilityInputs = new AbilityInput(shipInputs);
if (abilityInputs != prevAbilityInputs)
{
CmdUploadAbilityInput(abilityInputs);
}
/*
* if (cmdTimer.Update(Time.deltaTime))
* {
* CmdUploadInput(shipInputs);
* cmdTimer.Activate();
* }
*/
prevAbilityInputs = abilityInputs;
}
}
private void DebugInput(AbilityInput input)
{
Debug.DrawLine(transform.position, input.TargetPosition, Color.cyan);
}
/// <summary>
/// Is called when the ability handler wants to fire, but needs permission from the behaviour
/// </summary>
public virtual bool ShouldFire(AbilityInput input)
{
return(IsCooldownReady && input.FireButtonStay);
}
private void CmdUploadAbilityInput(AbilityInput abilites)
{
// server recieves inputs from client
shipInputs.boost = abilites.boost;
//Debug.Log("boost cmd recieved");
}
private void UpdateChargeEffect(AbilityInput input)
{
Effects.UpdateChargeEffects(input.TargetPosition);
Effects.UpdateColor(LifetimeColor);
}