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) { 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; }