private void Start()
{
movementData = FindObjectOfType <MovementData>();
direction = Vector3.zero;
movementData.RegisterObserver(this);
}
protected override void PlotVertex(MovementData data)
{
this.mScriptHost.X = data.X;
this.mScriptHost.XI = data.X;
this.mScriptHost.Y = data.Y;
this.mScriptHost.YI = data.Y;
this.mScriptHost.D = data.Distance;
this.mScriptHost.R = data.Rotation;
data.Method = this.Rectangular ? MovementMethod.Rectangular : MovementMethod.Polar;
if (RunScript(this.VertexScript, "vertex"))
{
if (this.Rectangular)
{
data.X = this.mScriptHost.X;
data.Y = this.mScriptHost.Y;
}
else
{
data.Distance = this.mScriptHost.D;
data.Rotation = this.mScriptHost.R;
}
data.Alpha = this.mScriptHost.Alpha;
}
}
public GroundedMovementRegime(
MovementData movementData,
float maxGroundedSpeed
) : base(movementData)
{
this.maxGroundedSpeed = maxGroundedSpeed;
}
/// <summary>
/// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
///
/// why do I do these things
/// </summary>
public void PopulateMovementData()
{
// Only populate the MovementData dictionary once,
if (MovementData.Any() || movementTileData == null)
{
return;
}
foreach (var movementData in movementTileData.movementData)
{
if (MovementData.ContainsKey(movementData.movementType))
{
continue;
}
MovementData.Add(movementData.movementType, movementData);
}
// If we have a general movement rule then assign it to any movement types that don't have data
if (MovementData.ContainsKey(MovementType.General))
{
var generalMovementRule = MovementData[MovementType.General];
foreach (var movementType in Enum.GetValues(typeof(MovementType)).Cast <MovementType>())
{
if (MovementData.ContainsKey(movementType))
{
continue;
}
MovementData.Add(movementType, generalMovementRule);
}
}
}
public bool Execute(GraphicEntity entity)
{
var find = entity.GetComponents <GeneralCameraComponent>();
if (!find.Any())
{
return(false);
}
var ccom = find.First();
var delta = InputState.Delta;
var p2 = InputState.CurrentPosition;
var data = new MovementData {
End = p2
};
entity
.GetOrCreateComponent(new CameraZoomingComponent {
State = ccom.GetState()
})
.Do(x => {
x.MovementData = data;
x.Delta = delta;
});
return(true);
}
public void TransportSucceededCommandExecuteShouldCallSendTransportSucceededUseCase()
{
var useCase = new Mock <ISendTransportSucceededUseCase>();
var serviceLocator = new Mock <IServiceLocator>();
serviceLocator.Setup(l => l.GetInstance <ISendTransportSucceededUseCase>()).Returns(useCase.Object);
ServiceLocator.SetLocatorProvider(() => serviceLocator.Object);
var expectedData = new MovementData();
expectedData.Barcode = "expected Barcode";
expectedData.Index = "1";
var expectedSource = "expected source";
var expectedInfo = "expected info";
var expectedTargetShelf = "expected target shelf";
var expectedTarget = "expected target";
var expectedSourceShelf = "expected source shelf";
var expectedQuantity = 2;
var expectedTicket = Guid.NewGuid();
var request = new MovementRequest
{
Info = expectedInfo, Quantity = expectedQuantity, Source = expectedSource, SourceCompartment = expectedSourceShelf, Target = expectedTarget,
TargetCompartment = expectedTargetShelf, Task = AutomationTasks.Transport, Ticket = expectedTicket, Timestamp = DateTime.UtcNow
};
request.Data.Add(expectedData);
var viewModel = new MovementRequestViewModel(request);
CommandRaised(viewModel);
viewModel.SendTransportSucceededCommand.Execute();
useCase.Verify(u => u.Execute(request));
CheckExecutesShouldBeFalse(viewModel);
CheckCommandRaises();
}
public MovementData OnMovement()
{
if (myUnits.Count == 0 || !firstMove)
return null;
UnitInfo unit = myUnits.ElementAt(0);
MovementData cmd = new MovementData();
cmd.UnitID = unit.UnitID;
cmd.FromX = unit.PositionX; cmd.FromY = unit.PositionY;
if (enemyCities.ElementAt(0).PositionY == myCities.ElementAt(0).PositionY) // Az x tengely mentén kell mozogni
{
int direction = (enemyCities.ElementAt(0).PositionX > myCities.ElementAt(0).PositionX) ? 1 : -1;
cmd.ToX = unit.PositionX + direction;
cmd.ToY = unit.PositionY;
}
else if (enemyCities.ElementAt(0).PositionX == myCities.ElementAt(0).PositionX) // Az y tengely mentén kell mozogni
{
int direction = (enemyCities.ElementAt(0).PositionY > myCities.ElementAt(0).PositionY) ? 1 : -1;
cmd.ToY = unit.PositionY + direction;
cmd.ToX = unit.PositionX;
}
if (cmd.ToX == enemyCities.ElementAt(0).PositionX && cmd.ToY == enemyCities.ElementAt(0).PositionY && turn != 25)
return null;
myUnits.ElementAt(0).PositionX = cmd.ToX;
myUnits.ElementAt(0).PositionY = cmd.ToY;
firstMove = false;
return cmd;
}
// Use this for initialization
void Start()
{
canDrop = true;
movement = new MovementData(3);
{
delay = gameObject.AddComponent <TimerRoutine>();
delay.initTimer(6f);
delay.executedFunction = resetBomb;
}
bombRange = 1;
sightRange = bombRange + 4;
BoxCollider2D col = gameObject.AddComponent <BoxCollider2D>();
col.size = new Vector2(1f * sightRange, 1f);
col.isTrigger = true;
col = gameObject.AddComponent <BoxCollider2D>();
col.size = new Vector2(1f, 1f * sightRange);
col.isTrigger = true;
dmgBody = transform.parent.GetChild(2).gameObject;
dmgBody.GetComponent <DefaultCharacter>().InitChar();
e_state = BomberState.E_NEUTRAL;
bombRef = null;
prevCellPos = GameModeManager.instance.gameGrid.GetWorldFlToCellPos(transform.position);
physBody = transform.parent.GetComponent <Rigidbody2D>();
anim = transform.parent.GetChild(3).GetChild(0).GetComponent <Animator>();
guide = transform.parent.GetComponent <BomberGuide>();
colcount = 0;
once = false;
}
public override byte[] GetPayload(WorldObject animationTarget)
{
MemoryStream stream = new MemoryStream();
BinaryWriter writer = new BinaryWriter(stream);
writer.Write((byte)MovementTypes.General); // movement_type
MotionFlags flags = MotionFlags.None;
if (HasTarget)
{
flags |= MotionFlags.HasTarget;
}
if (Jumping)
{
flags |= MotionFlags.Jumping;
}
writer.Write((byte)flags); // these can be or and has sticky object | is long jump mode |
writer.Write((ushort)Stance); // called command in the client
MovementStateFlag generalFlags = MovementData.MovementStateFlag;
generalFlags += (uint)Commands.Count << 7;
writer.Write((uint)generalFlags);
MovementData.Serialize(writer);
foreach (var item in Commands)
{
writer.Write((ushort)item.Motion);
writer.Write(animationTarget.Sequences.GetNextSequence(Sequence.SequenceType.Motion));
writer.Write(item.Speed);
}
return(stream.ToArray());
}
public void HandleActionJump(JumpPack jump)
{
var strength = Strength.Current;
var capacity = EncumbranceSystem.EncumbranceCapacity((int)strength, 0); // TODO: augs
var burden = EncumbranceSystem.GetBurden(capacity, EncumbranceVal ?? 0);
// calculate stamina cost for this jump
var staminaCost = MovementSystem.JumpStaminaCost(jump.Extent, burden, false);
//Console.WriteLine($"Strength: {strength}, Capacity: {capacity}, Encumbrance: {EncumbranceVal ?? 0}, Burden: {burden}, StaminaCost: {staminaCost}");
// TODO: ensure player has enough stamina to jump
UpdateVitalDelta(Stamina, -staminaCost);
//Console.WriteLine($"Jump velocity: {jump.Velocity}");
// set jump velocity
PhysicsObj.set_velocity(jump.Velocity, true);
// this shouldn't be needed, but without sending this update motion / simulated movement event beforehand,
// running forward and then performing a charged jump does an uncharged shallow arc jump instead
// this hack fixes that...
var movementData = new MovementData(this);
movementData.IsAutonomous = true;
movementData.MovementType = MovementType.Invalid;
movementData.Invalid = new MovementInvalid(movementData);
EnqueueBroadcast(new GameMessageUpdateMotion(this, movementData));
// broadcast jump
EnqueueBroadcast(new GameMessageVectorUpdate(this));
}
public void RequestUpdateMotion(uint holdKey, MovementData md, MotionItem[] commands)
{
new ActionChain(this, () =>
{
// Update our current style
if ((md.MovementStateFlag & MovementStateFlag.CurrentStyle) != 0)
{
MotionStance newStance = (MotionStance)md.CurrentStyle;
if (newStance != stance)
{
stance = (MotionStance)md.CurrentStyle;
}
}
md = md.ConvertToClientAccepted(holdKey, GetCreatureSkill(Skill.Run));
UniversalMotion newMotion = new UniversalMotion(stance, md);
// This is a hack to make walking work correctly. Og II
if (holdKey != 0 || (md.ForwardCommand == (uint)MotionCommand.WalkForward))
{
newMotion.IsAutonomous = true;
}
// FIXME(ddevec): May need to de-dupe animation/commands from client -- getting multiple (e.g. wave)
// FIXME(ddevec): This is the operation that should update our velocity (for physics later)
newMotion.Commands.AddRange(commands);
CurrentLandblock?.EnqueueBroadcastMotion(this, newMotion);
// TODO: use real motion / animation system from physics
CurrentMotionCommand = md.ForwardCommand;
}).EnqueueChain();
}
/// <summary>
/// Get the movement cost for this tile for a given movement type.
/// This will trigger populating the movement data for this tile data instance.
/// If no movement data is found it will return NaN to indicate this tile is impassible.
/// </summary>
/// <param name="movementType">The type of movement to check.</param>
/// <returns>The movement cost of the tile for the given movement type. Retuns NaN if no movement data is found.</returns>
public float GetMovementCost(MovementType movementType)
{
// Make sure our dumb dictionary of stupidity is populated before we check movement data for this tile data
PopulateMovementData();
return(MovementData.ContainsKey(movementType) && MovementData[movementType].Passable ? MovementData[movementType].MovementCost : float.NaN);
}
protected override void PlotVertex (MovementData data)
{
data.Method = MovementMethod.Rectangular;
data.X += (float) Math.Sin(data.X * SIN_BIAS) / SIN_DIVISOR;
data.Y += (float) Math.Sin(data.Y * SIN_BIAS) / SIN_DIVISOR;
}
// Use this for initialization
void Start()
{
movementScript = GameObject.FindGameObjectWithTag("AI").GetComponent<MovementAI>();
myMoveData = GetComponent<MovementData>();
myMoveData.position = transform.position;
myMoveData.velocity = new Vector3(1,0,0);
}
protected override void PlotVertex(MovementData data)
{
data.Method = MovementMethod.Rectangular;
data.X += (float)Math.Sin(data.X * SIN_BIAS) / SIN_DIVISOR;
data.Y += (float)Math.Sin(data.Y * SIN_BIAS) / SIN_DIVISOR;
}
protected override void PlotVertex(MovementData data)
{
data.Method = MovementMethod.Polar;
data.Distance -= (float)(rand.NextDouble() * 0.03);
data.Rotation += (float)(rand.NextDouble() * 0.025 - 0.0125);
}
private void DecompressIntoPowerup(JArray data, PowerupData powerup)
{
var id = ExtractValue <int>(data, _powerupContract.ID);
var disposed = ExtractValue <bool>(data, _powerupContract.Disposed);
var positionOffset = new Vector2(_initializationData.Configuration.HealthPackConfiguration.WIDTH * .5, _initializationData.Configuration.HealthPackConfiguration.HEIGHT * .5);
var position = new Vector2(ExtractValue <double>(data, _powerupContract.PositionX), ExtractValue <double>(data, _powerupContract.PositionY)) + positionOffset;
var powerupType = (PowerupType)ExtractValue <int>(data, _powerupContract.Type);
var movementData = new MovementData()
{
Position = position,
Rotation = 0
};
var lifeData = new LifeData()
{
Alive = true,
Health = 0,
};
powerup.Id = id;
powerup.Disposed = disposed;
powerup.Type = powerupType;
powerup.Movement = movementData;
powerup.Life = lifeData;
if (powerupType == PowerupType.HealthPack)
{
powerup.Width = _initializationData.Configuration.HealthPackConfiguration.WIDTH;
powerup.Height = _initializationData.Configuration.HealthPackConfiguration.HEIGHT;
powerup.Height = _initializationData.Configuration.HealthPackConfiguration.LIFE_SPAN;
}
}
public void BroadcastMovement(MoveToState moveToState)
{
var state = moveToState.RawMotionState;
// update current style
if ((state.Flags & RawMotionFlags.CurrentStyle) != 0)
{
// this lowercase stance field in Player doesn't really seem to be used anywhere
stance = state.CurrentStyle;
}
// update CurrentMotionState here for substates?
if ((state.Flags & RawMotionFlags.ForwardCommand) != 0)
{
if (((uint)state.ForwardCommand & (uint)CommandMask.SubState) != 0)
{
CurrentMotionState.SetForwardCommand(state.ForwardCommand);
}
}
else
{
CurrentMotionState.SetForwardCommand(MotionCommand.Ready);
}
if (state.CommandListLength > 0)
{
if (((uint)state.Commands[0].MotionCommand & (uint)CommandMask.SubState) != 0)
{
CurrentMotionState.SetForwardCommand(state.Commands[0].MotionCommand);
}
}
if (state.HasSoulEmote(false))
{
// prevent soul emote spam / bug where client sends multiples
var soulEmote = state.Commands[0].MotionCommand;
if (soulEmote == LastSoulEmote && DateTime.UtcNow < LastSoulEmoteEndTime)
{
state.Commands.Clear();
state.CommandListLength = 0;
}
else
{
var animLength = Physics.Animation.MotionTable.GetAnimationLength(MotionTableId, CurrentMotionState.Stance, soulEmote, state.Commands[0].Speed);
LastSoulEmote = soulEmote;
LastSoulEmoteEndTime = DateTime.UtcNow + TimeSpan.FromSeconds(animLength);
}
}
var movementData = new MovementData(this, moveToState);
var movementEvent = new GameMessageUpdateMotion(this, movementData);
EnqueueBroadcast(true, movementEvent); // shouldn't need to go to originating player?
// TODO: use real motion / animation system from physics
//CurrentMotionCommand = movementData.Invalid.State.ForwardCommand;
CurrentMovementData = movementData;
}
// Use this for initialization
public override void Start()
{
base.Start();
movementData = gameObject.GetComponent <MovementData>();
healthData = gameObject.GetComponent <HealthData> ();
movementData.rb = gameObject.GetComponent <Rigidbody2D> ();
}
private void UpdateLocalMovement()
{
if (State.PartyId == MobilePartyState.InvalidPartyId)
{
throw new Exception("Invalid party id!");
}
MobileParty party = m_Environment.GetMobilePartyByIndex(State.PartyId);
if (party == null)
{
return;
}
MovementData data = new MovementData
{
DefaultBehaviour = State.Movement.DefaultBehavior,
TargetPosition = State.Movement.Position,
TargetParty = State.Movement.TargetPartyIndex != MovementState.InvalidIndex ?
MBObjectManager.Instance.GetObject(State.Movement.TargetPartyIndex) as
MobileParty :
null,
TargetSettlement = State.Movement.SettlementIndex != MovementState.InvalidIndex ?
MBObjectManager.Instance.GetObject(
State.Movement.SettlementIndex) as Settlement :
null
};
Logger.Trace(
"[{tick}] Received move entity {id} ({party}) to {position}.",
Room.Tick,
Id,
party,
data);
m_Environment.TargetPosition.SetTyped(party, data);
}
public void Initialize(Population population, MovementData data)
{
this.MovementController = this.gameObject.GetComponent <MovementController>();
this.MovementData = data;
this.PopulationInfo = population;
this.gameObject.GetComponent <Animator>().runtimeAnimatorController = this.PopulationInfo.Species.AnimatorController;
}
internal override void ReadBody(ByteReader reader)
{
if (reader.BytesLeft < 2)
{
reader.ReadPad(1);
return;
}
byte itemCount = reader.ReadByte();
for (int i = 0; i < itemCount; i++)
{
var item = new ItemData();
item.Slot = reader.ReadByte();
item.ItemsInSlot = reader.ReadByte();
item.SpellCharges = reader.ReadByte();
item.ItemID = reader.ReadUInt32();
this.Items.Add(item);
}
this.LookAtType = reader.ReadByte();
if (this.LookAtType != 0)
{
this.LookAtPosition = reader.ReadVector3();
}
if (reader.BytesLeft < 1)
{
return;
}
this.MovementData = reader.ReadMovementDataWithHeader();
}
protected override void PlotVertex(MovementData data)
{
data.Method = MovementMethod.Rectangular;
data.X += (float)((random.NextDouble() - 0.5) / 32.0);
data.Y += (float)((random.NextDouble() - 0.5) / 32.0);
data.Alpha = 0.5f;
}
float GetDelta(ref MovementData movementData)
{
var radOffset = movementData.CycleOffset * (Mathf.PI * 2);
var time = CurrentTime * movementData.Speed;
return(movementData.Size * Mathf.Sin(time + radOffset));
}
public void SetNewEngineState(EngineState engineState, bool skipEngineStartUpSequence, bool sendMessages)
{
if (engineState == EngineState)
{
SetNewEngineState(engineState, true, false);
return;
}
EngineState oldState = EngineState;
if (oldState == EngineState.OFF && skipEngineStartUpSequence == false) // Do startup
{
if (sendMessages == true)
{
SendMessage("OnEngineStartUp", engineState, SendMessageOptions.DontRequireReceiver);
}
}
else
{
if (engineState == EngineState.OFF)
{
if (sendMessages == true)
{
SendMessage("OnEnginePowerDown", oldState, SendMessageOptions.DontRequireReceiver);
}
}
EngineState = engineState;
CurrentMovementData = GetCorrectMovementDataForEnginestate(EngineState);
if (sendMessages == true && engineState != EngineState.OFF && oldState != EngineState.OFF)
{
SendMessage("OnEngineChangeState", oldState, SendMessageOptions.DontRequireReceiver);
}
}
}
private static MovementData UpdateHorizontal(ref MovementData movementData, PlayerInputData inputData, PlayerMovementAbilityData movementAbilityData,
float deltaTime, PlayerStates states)
{
var vel = movementData.Velocity;
var maxHorizontalSpeed = inputData.FireKeep ? movementAbilityData.MaxHorizontalSpeedDashing : movementAbilityData.MaxHorizontalSpeed;
var horizontalAcc = inputData.FireKeep ? movementAbilityData.HorizontalDashingAcc : movementAbilityData.HorizontalAcc;
if (inputData.HorizontalInput != 0)
{
vel.x = math.clamp(vel.x + inputData.HorizontalInput * horizontalAcc * deltaTime,
-maxHorizontalSpeed, maxHorizontalSpeed);
}
else if (PlayerUtility.IsGrounded(states))
{
var sign = math.sign(vel.x);
var value = math.abs(vel.x);
var amountToReduce = movementAbilityData.HorizontalReverseAcc * deltaTime;
value = value < amountToReduce ? 0 : value - amountToReduce;
vel.x = sign * value;
}
movementData.Velocity = vel;
return(movementData);
}
private static void UpdateJumpKeep(ref PlayerStates states, ref MovementData movementData,
PlayerMovementAbilityData movementAbilityData,
PlayerInputData inputData, float deltaTime)
{
if (states.JumpKeepTime <= 0)
{
return;
}
if (!inputData.LastFrameJumpHit && !inputData.LastFrameJumpKeep ||
!inputData.JumpKeep)
{
states.JumpKeepTime = 0;
return;
}
states.JumpKeepTime -= deltaTime;
var vel = movementData.Velocity;
vel.y = movementAbilityData.JumpHitSpeed;
movementData.Velocity = vel;
if (states.JumpKeepTime < 0)
{
states.JumpKeepTime = 0;
}
}
protected override void PlotVertex(MovementData data) {
data.Method = MovementMethod.Rectangular;
switch (this.mHorizontalMirror) {
case HorizontalMirrorType.LeftToRight:
if (data.X == 1)
data.X = 0;
break;
case HorizontalMirrorType.RightToLeft:
if (data.X == 0)
data.X = 1;
break;
}
switch (this.mVerticalMirror) {
case VerticalMirrorType.TopToBottom:
if (data.Y == 0)
data.Y = 1;
break;
case VerticalMirrorType.BottomToTop:
if (data.Y == 1)
data.Y = 0;
break;
}
}
public void DisplayMovements()
{
movementData = Globals.movements[selectionController.getCont()];
nameMovement1.text = movementData.getMovementName();
imageMovement1.sprite = movementData.getMovementPicture();
movementData = Globals.movements[selectionController.getCont() + 1];
nameMovement2.text = movementData.getMovementName();
imageMovement2.sprite = movementData.getMovementPicture();
movementData = Globals.movements[selectionController.getCont() + 2];
nameMovement3.text = movementData.getMovementName();
imageMovement3.sprite = movementData.getMovementPicture();
/*if (gameObject.name == "Movement 1")
* {
* movementData = Globals.movements[selectionController.getCont()];
* //movementData.setMovementName(Globals.movements[0].getMovementName());
* //movementData.setMovementPicture(Globals.movements[0].getMovementPicture());
* }
* else if (gameObject.name == "Movement 2")
* movementData = Globals.movements[selectionController.getCont() + 1];
* else if (gameObject.name == "Movement 3")
* movementData = Globals.movements[selectionController.getCont() + 2];
* nameMovement1.text = movementData.getMovementName();
* imageMovement1.sprite = movementData.getMovementPicture();*/
}
protected override void PlotVertex(MovementData data)
{
data.Method = MovementMethod.Rectangular;
data.X += (float) ((random.NextDouble() - 0.5) / 32.0);
data.Y += (float) ((random.NextDouble() - 0.5) / 32.0);
data.Alpha = 0.5f;
}
private static MovementData DeserializeMovement(BinaryReader reader, MotionStateFlag flags)
{
MovementData ret = new MovementData();
if ((flags & MotionStateFlag.CurrentStyle) != 0)
{
ret.CurrentStyle = (ushort)reader.ReadUInt32();
}
if ((flags & MotionStateFlag.ForwardCommand) != 0)
{
ret.ForwardCommand = (ushort)reader.ReadUInt32();
}
// FIXME(ddevec): Holdkey?
if ((flags & MotionStateFlag.ForwardHoldKey) != 0)
{
reader.ReadUInt32();
}
if ((flags & MotionStateFlag.ForwardSpeed) != 0)
{
ret.ForwardSpeed = (ushort)reader.ReadSingle();
}
if ((flags & MotionStateFlag.SideStepCommand) != 0)
{
ret.SideStepCommand = (ushort)reader.ReadUInt32();
}
// FIXME(ddevec): Holdkey?
if ((flags & MotionStateFlag.SideStepHoldKey) != 0)
{
reader.ReadUInt32();
}
if ((flags & MotionStateFlag.SideStepSpeed) != 0)
{
ret.SideStepSpeed = (ushort)reader.ReadSingle();
}
if ((flags & MotionStateFlag.TurnCommand) != 0)
{
ret.TurnCommand = (ushort)reader.ReadUInt32();
}
// FIXME(ddevec): Holdkey?
if ((flags & MotionStateFlag.TurnHoldKey) != 0)
{
reader.ReadUInt32();
}
if ((flags & MotionStateFlag.TurnSpeed) != 0)
{
ret.TurnSpeed = (ushort)reader.ReadSingle();
}
return(ret);
}
private MovementData getForward()
{
if (forward == null)
{
forward = new MovementData();
}
return(forward);
}
public void SetMovementDataForEngineState(EngineState engineState, MovementData movementData)
{
if (engineMovementData.ContainsKey(engineState))
{
engineMovementData.Remove(engineState);
}
engineMovementData.Add(engineState, movementData);
}
// Use this for initialization
void Awake()
{
_movementScript = GameObject.FindGameObjectWithTag("AI").GetComponent<MovementAI>();
_myMoveData = GetComponent<MovementData>();
_targetMoveData = target.GetComponent<MovementData>();
_myMoveData.position = transform.position;
_currentHp = _maxHp;
anime = GetComponent<Animator>();
}
public static MovementData GetLongerMovement(MovementData movement1Pre, MovementData movement2Pre)
{
if (movement1Pre.doubleDataX.Count > movement2Pre.doubleDataX.Count)
{
return(movement1Pre);
}
return(movement2Pre);
}
public static MovementData GetShorterMovement(MovementData movement1Pre, MovementData movement2Pre)
{
if (movement1Pre.doubleDataX.Count <= movement2Pre.doubleDataX.Count)
{
return(movement1Pre);
}
return(movement2Pre);
}
private MovementData getSideways()
{
if (sideways == null)
{
sideways = new MovementData();
sideways.acceleration = forward.acceleration * 2;
sideways.maxSpeed = forward.maxSpeed / 2;
}
return sideways;
}
private MovementData getUp()
{
if (up == null)
{
up = new MovementData();
up.acceleration = forward.acceleration * 2;
up.maxSpeed = forward.maxSpeed / 2;
}
return up;
}
public void chase(MovementData target, MovementData self, float maxSpeed)
{
Vector3 direction = seek(target,self);
float distance = direction.magnitude;
Vector3 targetPredictedLocation = target.position + target.velocity;
Vector3 result = targetPredictedLocation - self.position;
if (result.magnitude > maxSpeed)
{
result.Normalize();
result *= maxSpeed;
}
self.velocity = result;
}
private void updateMovementData(MovementData movementData, KeyCode increase1, KeyCode increase2, KeyCode decrease1, KeyCode decrease2, KeyCode halt)
{
float deltaV = movementData.acceleration * Time.deltaTime;
if (IsSprinting())
deltaV *= sprintMultiplier;
if (Input.GetKey(increase1) || Input.GetKey(increase2))
movementData.speed += deltaV;
else if (Input.GetKey(decrease1) || Input.GetKey(decrease2))
movementData.speed -= deltaV;
else if (Input.GetKey(halt))
movementData.speed = 0;
else
{
movementData.speed *= movementData.decayRate;
if (Mathf.Abs(movementData.speed) < 0.01)
movementData.speed = 0;
}
float maxSpeed = movementData.maxSpeed;
if (IsSprinting())
maxSpeed *= sprintMultiplier;
movementData.speed = Mathf.Clamp(movementData.speed, -maxSpeed, maxSpeed);
}
private MovementData getForward()
{
if (forward == null)
forward = new MovementData();
return forward;
}
protected override void PlotVertex(MovementData data)
{
data.Method = MovementMethod.Polar;
data.Distance -= (float) (rand.NextDouble() * 0.03);
data.Rotation += (float) (rand.NextDouble() * 0.025 - 0.0125);
}
public override void RenderFrame(IController controller) {
if (this.haveVBO == null)
this.haveVBO = Gl.IsExtensionSupported("GL_ARB_vertex_buffer_object");
Gl.glMatrixMode(Gl.GL_PROJECTION);
Gl.glPushMatrix();
Gl.glLoadIdentity();
Gl.glPushAttrib(Gl.GL_ENABLE_BIT);
Gl.glEnable(Gl.GL_TEXTURE_2D);
Gl.glDisable(Gl.GL_DEPTH_TEST);
Gl.glTexEnvf(Gl.GL_TEXTURE_ENV, Gl.GL_TEXTURE_ENV_MODE, Gl.GL_DECAL);
this.mTexture.SetTextureSize(controller.Width,
controller.Height);
Gl.glBindTexture(Gl.GL_TEXTURE_2D, this.mTexture.TextureId);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_S,
this.Wrap ? Gl.GL_REPEAT : Gl.GL_CLAMP);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_T,
this.Wrap ? Gl.GL_REPEAT : Gl.GL_CLAMP);
Gl.glCopyTexImage2D(Gl.GL_TEXTURE_2D, 0, Gl.GL_RGB, 0, 0,
controller.Width, controller.Height, 0);
MovementData data = new MovementData();
if (!this.mStatic || this.mStaticDirty) {
int cachei = 0;
int texi = 0;
for (int yi = 0; yi < this.YResolution; yi++) {
for (int xi = 0; xi < this.XResolution; xi++) {
ValueCache cache = this.mCache[cachei++];
data.X = cache.X;
data.Y = cache.Y;
data.Distance = cache.Distance;
data.Rotation = cache.Rotation;
this.PlotVertex(data);
float xo, yo;
if (data.Method == MovementMethod.Rectangular) {
xo = data.X;
yo = data.Y;
} else {
xo = (data.Distance * (float) Math.Cos(data.Rotation) + 1) / 2;
yo = (data.Distance * (float) Math.Sin(data.Rotation) + 1) / 2;
}
//pd.Alpha = data.Alpha;
this.mTexCoordCache[texi++] = xo;
this.mTexCoordCache[texi++] = yo;
}
}
this.mStaticDirty = false;
}
Gl.glColor4f(1, 1, 1, 1);
if (this.haveVBO ?? false) {
if (this.mVertexCache != null) {
if (this.mVertexVBO >= 0) {
Gl.glDeleteBuffersARB(1, ref this.mVertexVBO);
}
Gl.glGenBuffersARB(1, out this.mVertexVBO);
Gl.glBindBufferARB(Gl.GL_ARRAY_BUFFER_ARB, this.mVertexVBO);
Gl.glBufferDataARB(Gl.GL_ARRAY_BUFFER_ARB,
new IntPtr(this.mVertexCache.Length * 4),
this.mVertexCache,
Gl.GL_STATIC_DRAW_ARB);
this.mVertexCache = null;
Gl.glBindBufferARB(Gl.GL_ARRAY_BUFFER_ARB, 0);
}
if (this.mIndexCache != null) {
if (this.mIndexVBO >= 0) {
Gl.glDeleteBuffersARB(1, ref this.mIndexVBO);
}
Gl.glGenBuffersARB(1, out this.mIndexVBO);
Gl.glBindBufferARB(Gl.GL_ELEMENT_ARRAY_BUFFER_ARB, this.mIndexVBO);
Gl.glBufferDataARB(Gl.GL_ELEMENT_ARRAY_BUFFER_ARB,
new IntPtr(this.mIndexCache.Length * 4),
this.mIndexCache,
Gl.GL_STATIC_DRAW_ARB);
this.mIndexVBOSize = this.mIndexCache.Length;
this.mIndexCache = null;
}
}
Gl.glEnableClientState(Gl.GL_VERTEX_ARRAY);
Gl.glEnableClientState(Gl.GL_TEXTURE_COORD_ARRAY);
Gl.glTexCoordPointer(2, Gl.GL_FLOAT, 0, this.mTexCoordCache);
if (this.haveVBO ?? false) {
Gl.glBindBufferARB(Gl.GL_ARRAY_BUFFER_ARB, this.mVertexVBO);
Gl.glBindBufferARB(Gl.GL_ELEMENT_ARRAY_BUFFER_ARB, this.mIndexVBO);
Gl.glVertexPointer(2, Gl.GL_FLOAT, 0, IntPtr.Zero);
Gl.glDrawElements(Gl.GL_QUADS,
this.mIndexVBOSize,
Gl.GL_UNSIGNED_INT,
IntPtr.Zero);
Gl.glBindBufferARB(Gl.GL_ARRAY_BUFFER_ARB, 0);
Gl.glBindBufferARB(Gl.GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
} else {
Gl.glVertexPointer(2, Gl.GL_FLOAT, 0, this.mVertexCache);
Gl.glDrawElements(Gl.GL_QUADS,
this.mIndexCache.Length,
Gl.GL_UNSIGNED_INT,
this.mIndexCache);
}
Gl.glDisableClientState(Gl.GL_VERTEX_ARRAY);
Gl.glDisableClientState(Gl.GL_TEXTURE_COORD_ARRAY);
Gl.glPopAttrib();
Gl.glPopMatrix();
}
protected override void PlotVertex(MovementData data)
{
data.Method = MovementMethod.Polar;
data.Distance *= 0.995f - (0.02f * this.factor);
}
public MovementData OnMovement()
{
if (myUnits.Count == 0)
return null;
int unitNum = -1;
for (int i = 0; i < myUnits.Count; i++)
{
if (myUnits.ElementAt(i).MovementPoints > 0)
{
unitNum = i;
break;
}
}
if (unitNum == -1)
return null;
UnitInfo unit = myUnits.ElementAt(unitNum);
Random rand = new Random((int)DateTime.Now.Ticks);
List<CityInfo> enemies = getClosestTowns(unit);
CityInfo enemy = enemies.ElementAt(rand.Next(enemies.Count));
MovementData cmd = new MovementData();
cmd.UnitID = unit.UnitID;
cmd.FromX = unit.PositionX; cmd.FromY = unit.PositionY;
if (enemy.PositionY == unit.PositionY) // Az x tengely mentén kell mozogni
{
int direction = (enemy.PositionX > unit.PositionX) ? 1 : -1;
cmd.ToX = unit.PositionX + direction;
cmd.ToY = unit.PositionY;
}
else if (enemy.PositionX == unit.PositionX) // Az y tengely mentén kell mozogni
{
int direction = (enemy.PositionY > unit.PositionY) ? 1 : -1;
cmd.ToY = unit.PositionY + direction;
cmd.ToX = unit.PositionX;
}
else
{
int directionX = (enemy.PositionX > unit.PositionX) ? 1 : -1;
int directionY = (enemy.PositionY > unit.PositionY) ? 1 : -1;
cmd.ToX = unit.PositionX + directionX;
cmd.ToY = unit.PositionY + directionY;
}
if (!shouldMove(unit, cmd.ToX, cmd.ToY))
{
myUnits.ElementAt(unitNum).MovementPoints = 0;
return new MovementData() { FromX = unit.PositionX, FromY = unit.PositionY, ToY = unit.PositionY, ToX = unit.PositionX, UnitID = unit.UnitID };
}
myUnits.ElementAt(unitNum).MovementPoints--;
myUnits.ElementAt(unitNum).PositionX = cmd.ToX;
myUnits.ElementAt(unitNum).PositionY = cmd.ToY;
return cmd;
}
public MovementData OnMovement()
{
int unitNum = -1;
for (int i = 0; i < myUnits.Count; i++)
{
if (myUnits.ElementAt(i).MovementPoints > 0)
{
unitNum = i;
break;
}
}
if (unitNum == -1)
return null;
UnitInfo unit = myUnits.ElementAt(unitNum);
CityInfo enemy = null;
List<CityInfo> gyengek = new List<CityInfo>();
for (int i = 0; i < enemyCities.Count; i++)
{
if (vedelem(enemyCities.ElementAt(i)) < 2)
{
gyengek.Add(enemyCities.ElementAt(i));
}
}
enemy = getBest(gyengek, unit);
if (enemy == null)
enemy = enemyCities.ElementAt(0);
MovementData cmd = new MovementData();
cmd.FromX = unit.PositionX; cmd.FromY = unit.PositionY;
cmd.UnitID = unit.UnitID;
if (enemy.PositionX == unit.PositionX)
{
int direction = (enemy.PositionY < unit.PositionY) ? -1 : 1;
cmd.ToX = unit.PositionX;
cmd.ToY = unit.PositionY + direction;
}
else if (enemy.PositionY == unit.PositionY)
{
int direction = (enemy.PositionX < unit.PositionX) ? -1 : 1;
cmd.ToY = unit.PositionY;
cmd.ToX = unit.PositionX + direction;
}
else
{
int directionX = (enemy.PositionX < unit.PositionX) ? -1 : 1;
int directionY = (enemy.PositionY < unit.PositionY) ? -1 : 1;
cmd.ToX = unit.PositionX + directionX;
cmd.ToY = unit.PositionY + directionY;
}
myUnits.ElementAt(unitNum).MovementPoints--;
myUnits.ElementAt(unitNum).PositionX = cmd.ToX;
myUnits.ElementAt(unitNum).PositionY = cmd.ToY;
return cmd;
}
protected override void PlotVertex(MovementData data) {
this.mScriptHost.X = data.X;
this.mScriptHost.XI = data.X;
this.mScriptHost.Y = data.Y;
this.mScriptHost.YI = data.Y;
this.mScriptHost.D = data.Distance;
this.mScriptHost.R = data.Rotation;
data.Method = this.Rectangular ? MovementMethod.Rectangular : MovementMethod.Polar;
if (RunScript(this.VertexScript, "vertex")) {
if (this.Rectangular) {
data.X = this.mScriptHost.X;
data.Y = this.mScriptHost.Y;
} else {
data.Distance = this.mScriptHost.D;
data.Rotation = this.mScriptHost.R;
}
data.Alpha = this.mScriptHost.Alpha;
}
}
protected override void PlotVertex(MovementData data)
{
data.Method = MovementMethod.Polar;
float d = data.Distance;
data.Distance *= 0.995f - (0.015f * factor);
data.Rotation += (float) Math.Sin(Math.PI * 2 + d * 8 + time + factor * 4) * factor / 50;
data.Alpha = 0.75f - (d / 3);
}
// Use this for initialization
void Start()
{
movementScript = GameObject.FindGameObjectWithTag("AI").GetComponent<MovementAI>();
myMoveData = GetComponent<MovementData>();
}
protected abstract void PlotVertex(MovementData data);
public override void RenderFrame(IController controller)
{
Gl.glMatrixMode(Gl.GL_PROJECTION);
Gl.glPushMatrix();
Gl.glLoadIdentity();
Gl.glPushAttrib(Gl.GL_ENABLE_BIT);
Gl.glEnable(Gl.GL_TEXTURE_2D);
Gl.glDisable(Gl.GL_DEPTH_TEST);
Gl.glTexEnvf(Gl.GL_TEXTURE_ENV, Gl.GL_TEXTURE_ENV_MODE, Gl.GL_DECAL);
this.mTexture.SetTextureSize(controller.Width,
controller.Height);
Gl.glBindTexture(Gl.GL_TEXTURE_2D, this.mTexture.TextureId);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_S,
this.Wrap ? Gl.GL_REPEAT : Gl.GL_CLAMP);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_T,
this.Wrap ? Gl.GL_REPEAT : Gl.GL_CLAMP);
Gl.glCopyTexImage2D(Gl.GL_TEXTURE_2D, 0, Gl.GL_RGB, 0, 0,
controller.Width, controller.Height, 0);
PointData pd;
MovementData data = new MovementData();
if (!this.mStatic || this.mStaticDirty) {
for (int yi = 0; yi < this.YResolution; yi++) {
for (int xi = 0; xi < this.XResolution; xi++) {
data.X = (float) xi / (this.XResolution - 1);
data.Y = (float) yi / (this.YResolution - 1);
float xp = data.X * 2 - 1;
float yp = data.Y * 2 - 1;
data.Distance = (float) Math.Sqrt((xp * xp) + (yp * yp));
data.Rotation = (float) Math.Atan2(yp, xp);
this.PlotVertex(data);
if (data.Method == MovementMethod.Rectangular) {
pd.XOffset = data.X;
pd.YOffset = data.Y;
} else {
pd.XOffset = (data.Distance * (float) Math.Cos(data.Rotation) + 1) / 2;
pd.YOffset = (data.Distance * (float) Math.Sin(data.Rotation) + 1) / 2;
}
pd.Alpha = data.Alpha;
this.mPointData[xi, yi] = pd;
}
}
this.mStaticDirty = false;
}
Gl.glColor4f(1, 1, 1, 1);
Gl.glBegin(Gl.GL_QUADS);
for (int yi = 0; yi < this.YResolution - 1; yi++) {
for (int xi = 0; xi < this.XResolution - 1; xi++) {
this.RenderVertex(xi, yi );
this.RenderVertex(xi + 1, yi );
this.RenderVertex(xi + 1, yi + 1);
this.RenderVertex(xi, yi + 1);
}
}
Gl.glEnd();
Gl.glPopAttrib();
Gl.glPopMatrix();
}
//seek behavior
public Vector3 seek(MovementData target,MovementData self)
{
Vector3 position = target.position - self.position;
return position;
}
void Start()
{
_moveData = GetComponent<MovementData>();
}
protected override void PlotVertex(MovementData data)
{
data.Method = MovementMethod.Polar;
data.Rotation = (float) Math.Cos(data.Rotation * 4 - rr / 4) + rr;
data.Distance *= 0.75f;
}
