public static void Init(Control control, Control container, Direction direction) { bool Dragging = false; Point DragStart = Point.Empty; control.MouseDown += delegate(object sender, MouseEventArgs e) { Dragging = true; DragStart = new Point(e.X, e.Y); control.Capture = true; }; control.MouseUp += delegate(object sender, MouseEventArgs e) { Dragging = false; control.Capture = false; }; control.MouseMove += delegate(object sender, MouseEventArgs e) { if (Dragging) { if (direction != Direction.Vertical) container.Left = Math.Max(0, e.X + container.Left - DragStart.X); if (direction != Direction.Horizontal) container.Top = Math.Max(0, e.Y + container.Top - DragStart.Y); } }; }
public void MoveScreen(Direction dd) { using (var w = Window.ForegroundWindow()) { var currentScreenRect = w.ScreenRect(); var hw = currentScreenRect.Width / 2; var hh = currentScreenRect.Height / 2; var nextPoint = currentScreenRect.Location; switch (dd) { case Direction.Left: nextPoint.Offset(-1, hh); break; case Direction.Up: nextPoint.Offset(hw, -1); break; case Direction.Right: nextPoint.Offset(currentScreenRect.Width + 1, hh); break; case Direction.Down: nextPoint.Offset(hw, currentScreenRect.Height + 1); break; } var newScreen = Screen.FromPoint(nextPoint); var newOffset = RepositionPoint(w.NormalRectangle.Location, currentScreenRect.Location, newScreen.WorkingArea.Location); w.MoveTo(newOffset); } }
public void ThrowsArgumentOutOfRangeException_WhenShipIsOutOfBoard(byte x, byte y, Direction direction) { Assert.Throws<ArgumentOutOfRangeException>(() => { board.Add(new Battleship(x, y, direction)); }); }
public override bool OnMoveInto( Mobile m, Direction d, Point3D newLocation, Point3D oldLocation ) { if ( m.AccessLevel > AccessLevel.Player || Contains( oldLocation ) ) return true; // do they have enough faction to enter? XmlMobFactions a = (XmlMobFactions)XmlAttach.FindAttachment(m, typeof(XmlMobFactions)); if(a == null) return false; int fac = a.GetFactionLevel(m_FactionType); if(fac < FactionLevel) { // throttle message display if(DateTime.Now - m_lastmsg > TimeSpan.FromSeconds(1)) { m.SendMessage("Your {0} faction is too low to enter here", FactionType); m_lastmsg = DateTime.Now; } return false; } return true; }
public Rotation(Direction d, float xr, float yr, float zr) { this.dir = d; this.xRot = xr; this.yRot = yr; this.zRot = zr; }
private bool Move(Direction direction) { if (Editor.WebEditor.Host == null) return false; var point = _textView.BufferGraph.MapDownToInsertionPoint(_textView.Caret.Position.BufferPosition, PointTrackingMode.Positive, ts => ts.ContentType.IsOfType(Editor.CssContentTypeDefinition.CssContentType)); if (point == null) return false; var tree = CssEditorDocument.FromTextBuffer(point.Value.Snapshot.TextBuffer); ParseItem item = tree.StyleSheet.ItemBeforePosition(point.Value.Position); if (item == null) return false; NumericalValue unit = item.FindType<NumericalValue>(); if (unit != null) { return HandleUnits(direction, unit, point.Value.Snapshot); } HexColorValue hex = item.FindType<HexColorValue>(); if (hex != null) { return HandleHex(direction, hex, point.Value.Snapshot); } return false; }
public static Direction OppositeDirection(Direction from) { switch (from) { case Direction.Northwest: return Direction.Southeast; case Direction.North: return Direction.South; case Direction.Northeast: return Direction.Southwest; case Direction.East: return Direction.West; case Direction.West: return Direction.East; case Direction.Southeast: return Direction.Northwest; case Direction.South: return Direction.North; case Direction.Southwest: return Direction.Northeast; case Direction.Up: return Direction.Down; case Direction.Down: return Direction.Up; } return Direction.Here; }
public static void BuildRenderer(Chunk chunk, BlockPos pos, MeshData meshData, Direction direction, Vector3 ModelSize, Vector3 ConnMeshSizeX, Vector3 ConnMeshSizeY, Vector3 ConnMeshSizeZ, Direction[] Dir) { MakeStickFace(chunk, pos, meshData, direction, false, ModelSize); Debug.Log(Dir.Length); if (Dir.Length > 0) MakeFenceFace(chunk, pos, meshData, direction, false, ModelSize, ConnMeshSizeX, ConnMeshSizeY, ConnMeshSizeZ, Dir); }
public void DrawMouse(Position position, Direction direction) { MousePosition = position; MouseDirection = direction; PrepareMouse(); Invalidate(); }
public static Point ConvertDirectionToDestinationPoint(Point initial, Direction direction) { Point destPoint; switch (direction) { case Direction.North: destPoint = new Point(initial.X, initial.Y - 1); break; case Direction.South: destPoint = new Point(initial.X, initial.Y + 1); break; case Direction.West: destPoint = new Point(initial.X - 1, initial.Y); break; case Direction.East: destPoint = new Point(initial.X + 1, initial.Y); break; case Direction.Northeast: destPoint = new Point(initial.X + 1, initial.Y - 1); break; case Direction.Northwest: destPoint = new Point(initial.X - 1, initial.Y - 1); break; case Direction.Southeast: destPoint = new Point(initial.X + 1, initial.Y + 1); break; case Direction.Southwest: destPoint = new Point(initial.X - 1, initial.Y + 1); break; default: throw new ArgumentException("ConvertDirectionToDestinationPoint - Invalid Direction"); } return destPoint; }
public Alert ExitAlertCreate(Bar exitBar, Position position, double stopOrLimitPrice, string signalName, Direction direction, MarketLimitStop exitMarketLimitStop) { this.checkThrowEntryBarIsValid(exitBar); this.checkThrowPositionToCloseIsValid(position); double priceScriptOrStreaming = stopOrLimitPrice; OrderSpreadSide orderSpreadSide = OrderSpreadSide.Unknown; if (exitMarketLimitStop == MarketLimitStop.Market) { priceScriptOrStreaming = this.getStreamingPriceForMarketOrder(exitMarketLimitStop, direction, out orderSpreadSide); } PositionLongShort longShortFromDirection = MarketConverter.LongShortFromDirection(direction); double exitPriceScript = exitBar.ParentBars.SymbolInfo.RoundAlertPriceToPriceLevel( priceScriptOrStreaming, true, longShortFromDirection, exitMarketLimitStop); Alert alert = new Alert(exitBar, position.Shares, exitPriceScript, signalName, direction, exitMarketLimitStop, orderSpreadSide, //this.executor.Script, this.executor.Strategy); alert.AbsorbFromExecutor(executor); alert.PositionAffected = position; // moved to CallbackAlertFilled - we can exit by TP or SL - and position has no clue which Alert was filled!!! //position.ExitCopyFromAlert(alert); alert.PositionAffected.ExitAlertAttach(alert); return alert; }
/// <summary> /// Removes the specified number of characters in the position defined by startIndex and endIndex. /// </summary> /// <param name="startIndex">Where to start removing characters. Base 0.</param> /// <param name="direction">Which direction the removal of characters goes.</param> /// <param name="nrOfCharacters">The number of characters to remove. 0 to make it until the end/beginning.</param> /// <param name="textFound">The text at which to stop removing characters. Null or empty to not search for text to stop.</param> /// <param name="applyTo">Whether the removal of characters applies only to the filename or only to the extension or both. /// In order to apply to both, two separate commands need to be issued.</param> public CommandRemoveByPosition(int startIndex, Direction direction, int nrOfCharacters, string textFound = "", CommandApplyTo applyTo = CommandApplyTo.Filename) { if (IsUntilBeginningOrEnd()) description = string.Format("Remove characters starting at {0} until {1}", startIndex, direction == Direction.Forward ? "the end" : "the beginning"); else description = string.Format("Remove {0} character{1} {2} starting at {3}", nrOfCharacters, nrOfCharacters == 1 ? "" : "s", direction == Direction.Forward ? "forwards" : "backwards", startIndex); if (!string.IsNullOrEmpty(textFound)) { description += string.Format(" or the text \"{0}\" is found, whichever comes first", textFound); } description += string.Format(" applying to {0}", applyTo == CommandApplyTo.Filename ? "the filename" : "the extension"); this.startIndex = startIndex; this.nrOfCharacters = nrOfCharacters; this.direction = direction; this.textFound = textFound; this.applyTo = applyTo; }
private object ConvertIdentifier( object value, Item item, Direction direction, Guid providerId, string itemType) { if (value != null && !string.IsNullOrWhiteSpace(value.ToString())) { if (direction == Direction.Packaging) { var guid = Dependencies.ConvertIdentifier(value.ToString(), IdentifierReplaceDirection.FromNodeIdToGuid); // add dependency for the item var name = string.Concat(itemType, " from picker"); var dependency = new Dependency(name, guid, providerId); item.Dependencies.Add(dependency); return guid; } else if (direction == Direction.Extracting) { return Dependencies.ConvertIdentifier(value.ToString(), IdentifierReplaceDirection.FromGuidToNodeId); } } return value; }
public Alert EntryAlertCreate(Bar entryBar, double stopOrLimitPrice, string entrySignalName, Direction direction, MarketLimitStop entryMarketLimitStop) { this.checkThrowEntryBarIsValid(entryBar); double priceScriptOrStreaming = stopOrLimitPrice; OrderSpreadSide orderSpreadSide = OrderSpreadSide.Unknown; if (entryMarketLimitStop == MarketLimitStop.Market) { priceScriptOrStreaming = this.getStreamingPriceForMarketOrder(entryMarketLimitStop, direction, out orderSpreadSide); } PositionLongShort longShortFromDirection = MarketConverter.LongShortFromDirection(direction); // ALREADY_ALIGNED_AFTER GetAlignedBidOrAskForTidalOrCrossMarketFromStreaming double entryPriceScript = entryBar.ParentBars.SymbolInfo.RoundAlertPriceToPriceLevel( priceScriptOrStreaming, true, longShortFromDirection, entryMarketLimitStop); double shares = this.executor.PositionSizeCalculate(entryBar, entryPriceScript); Alert alert = new Alert(entryBar, shares, entryPriceScript, entrySignalName, direction, entryMarketLimitStop, orderSpreadSide, //this.executor.Script, this.executor.Strategy); alert.AbsorbFromExecutor(executor); return alert; }
public void Attack(Direction direction, Random random) { foreach (Enemy enemy in Enemies) { enemy.Move(random); } }
public ControlPage() { this.InitializeComponent(); turn = Turn.none; direction = Direction.none; accelerometer = App.accelerometer; bluetooth = App.bluetooth; arduino = App.arduino; if( accelerometer == null || bluetooth == null || arduino == null ) { Frame.Navigate( typeof( MainPage ) ); return; } startButton.IsEnabled = true; stopButton.IsEnabled = true; disconnectButton.IsEnabled = true; bluetooth.ConnectionLost += Bluetooth_ConnectionLost; keepScreenOnRequest = new DisplayRequest(); keepScreenOnRequest.RequestActive(); App.arduino.pinMode( LR_DIRECTION_CONTROL_PIN, PinMode.OUTPUT ); App.arduino.pinMode( FB_DIRECTION_CONTROL_PIN, PinMode.OUTPUT ); App.arduino.pinMode( LR_MOTOR_CONTROL_PIN, PinMode.PWM ); App.arduino.pinMode( FB_MOTOR_CONTROL_PIN, PinMode.PWM ); App.arduino.pinMode(HEARTBEAT_LED_PIN, PinMode.OUTPUT); }
private void CheckDiagonal(BoardMeta boardMeta, int row, int column, Direction direction, PlayerId playerId) { int nextRow = DirectionUtil.getNextRow (row, direction); int nextColumn = DirectionUtil.getNextColumn (column, direction); TileMeta tileMeta = boardMeta.getTile (nextRow, nextColumn); if (tileMeta != null) { PieceMeta pieceMeta = tileMeta.pieceMeta; if (pieceMeta != null) { if(pieceMeta.playerId == playerId){ // protect tileMeta.protectList.Add(new MoveMeta(direction, 1)); } else{ // active threat and move tileMeta.moveList.Add(new MoveMeta(direction, 1)); tileMeta.activeThreatList.Add(new MoveMeta(direction, 1)); } } else { // passive threat tileMeta.passiveThreatList.Add(new MoveMeta(direction, 1)); } } }
public DynamicObject(Position topLeft, char[,] texture, int speed, Direction direction) : base(topLeft, texture) { this.Speed = speed; this.state = this.Speed; this.ObjDirection = direction; }
public Line(Vector2 newStart, Vector2 newEnd, Color colour, Direction newDir) { start = newStart; end = newEnd; drawColour = colour; myDir = newDir; }
public void addAuto(Auto auto, Direction afkomst) { Direction[] choose = new Direction[3]; switch (afkomst) { case Direction.NORTH: choose[0] = Direction.SOUTH; choose[1] = Direction.EAST; choose[2] = Direction.WEST; break; case Direction.SOUTH: choose[0] = Direction.NORTH; choose[1] = Direction.EAST; choose[2] = Direction.WEST; break; case Direction.EAST: choose[0] = Direction.NORTH; choose[1] = Direction.SOUTH; choose[2] = Direction.WEST; break; case Direction.WEST: choose[0] = Direction.NORTH; choose[1] = Direction.SOUTH; choose[2] = Direction.EAST; break; } auto.kiesRichting(choose); getWachtrij(afkomst, auto.Richting).Add(auto); }
public Line(Vector2 newStart, Vector2 newEnd, Color colour) { start = newStart; end = newEnd; drawColour = colour; myDir = Direction.Forwards; }
void OnTriggerEnter2D(Collider2D other) { Tile tile = other.GetComponent<Tile>(); if (tile != null) { Position = tile.Position; ProcessMovement(); if (tile.gameObject == GameManager.gameManager.TeleporterLeft.gameObject && Direction == Direction.None) { Vector3 tempPos = GameManager.gameManager.TeleporterRight.transform.position; tile.GetComponent<AudioSource>().Play(); tempPos.z = transform.position.z; transform.position = tempPos; Direction = Direction.Left; } if (tile.gameObject == GameManager.gameManager.TeleporterRight.gameObject && Direction == Direction.None) { Vector3 tempPos = GameManager.gameManager.TeleporterLeft.transform.position; tile.GetComponent<AudioSource>().Play(); tempPos.z = transform.position.z; transform.position = tempPos; Direction = Direction.Right; } } }
public void ChangeDirection(Direction value) { Direction opposite = Direction.Left; switch (value) { case Direction.Up: opposite = Direction.Down; break; case Direction.Down: opposite = Direction.Up; break; case Direction.Left: opposite = Direction.Right; break; case Direction.Right: opposite = Direction.Left; break; } // must not move snake backwards except when it is only snake head if (opposite != _currentDirection || SnakeBody.Count == 1) { _currentDirection = value; } }
//! Convert Map.Direction to LookDirection. public static LookDirection Convert(Direction Dir) { LookDirection direction = LookDirection.EAST; switch(Dir) { case he.Direction.EAST: direction = LookDirection.EAST; break; case he.Direction.NORTH: direction = LookDirection.NORTH; break; case he.Direction.NORTH_EAST: direction = LookDirection.NORTHEAST; break; case he.Direction.NORTH_WEST: direction = LookDirection.NORTHWEST; break; case he.Direction.SOUTH: direction = LookDirection.SOUTH; break; case he.Direction.SOUTH_EAST: direction = LookDirection.SOUTHEAST; break; case he.Direction.SOUTH_WEST: direction = LookDirection.SOUTHWEST; break; case he.Direction.WEST: direction = LookDirection.WEST; break; } return direction; }
public Coords NeighborInDirection(Direction dir) { switch (dir) { case (Direction.Northeast): return new Coords(this.Type, this.X + 1, this.Y - 1); case (Direction.East): return new Coords(this.Type, this.X + 1, this.Y); case (Direction.Southeast): return new Coords(this.Type, this.X + 1, this.Y + 1); case (Direction.South): return new Coords(this.Type, this.X, this.Y + 1); case (Direction.Southwest): return new Coords(this.Type, this.X - 1, this.Y + 1); case (Direction.West): return new Coords(this.Type, this.X - 1, this.Y); case (Direction.Northwest): return new Coords(this.Type, this.X - 1, this.Y - 1); case (Direction.North): return new Coords(this.Type, this.X, this.Y - 1); } // This code should be unreachable. Added because compiler wants it. return this; }
public Direction GetNextMove(IGameBoard board, bool lastMoveResult) { if (lastMoveResult) return currentDirection; switch (currentDirection) { case Direction.Up: currentDirection = Direction.Left; break; case Direction.Left: currentDirection = Direction.Down; break; case Direction.Down: currentDirection = Direction.Right; break; case Direction.Right: currentDirection = Direction.Up; break; default: throw new Exception("TILT - Cannot get here, what happened?"); } return currentDirection; }
public override bool OnMoveInto(Mobile m, Direction d, Point3D newLocation, Point3D oldLocation) { if (m.Player && Factions.Sigil.ExistsOn(m)) { m.SendMessage(0x22, "You are holding a sigil and cannot enter this zone."); return false; } PlayerMobile pm = m as PlayerMobile; if (pm == null && m is BaseCreature) { BaseCreature bc = (BaseCreature)m; if (bc.Summoned) pm = bc.SummonMaster as PlayerMobile; } if (pm != null && pm.DuelContext != null && pm.DuelContext.StartedBeginCountdown) return true; if (DuelContext.CheckCombat(m)) { m.SendMessage(0x22, "You have recently been in combat and cannot enter this zone."); return false; } return base.OnMoveInto(m, d, newLocation, oldLocation); }
public bool CheckCollisionDirection(Direction direction) { bool directionResult = false; float extraSize = 0.025f; float ownerHalfWidth = gameObject.rigidbody2D.renderer.bounds.size.x / 2 + extraSize; float ownerHalfHeight = gameObject.rigidbody2D.renderer.bounds.size.y / 2 + extraSize; switch(direction) { case Direction.UP: directionResult = CheckRayTrace(Vector2.up, ownerHalfHeight); break; case Direction.DOWN: directionResult = CheckRayTrace(-Vector2.up, ownerHalfHeight); break; case Direction.LEFT: directionResult = CheckRayTrace(-Vector2.right, ownerHalfWidth); break; case Direction.RIGHT: directionResult = CheckRayTrace(Vector2.right, ownerHalfWidth); break; } return directionResult; }
public void SafeMoveTo(Direction direction) { if (direction == Direction.NORTH) { SwapTo(X, Y - 1, Z, true); } else if (direction == Direction.EAST) { SwapTo(X + 1, Y, Z, true); } else if (direction == Direction.SOUTH) { SwapTo(X, Y + 1, Z, true); } else if (direction == Direction.WEST) { SwapTo(X - 1, Y, Z, true); } else if (direction == Direction.NORTHEAST) { SwapTo(X + 1, Y - 1, Z, true); } else if (direction == Direction.SOUTHEAST) { SwapTo(X + 1, Y + 1, Z, true); } else if (direction == Direction.NORTHWEST) { SwapTo(X - 1, Y - 1, Z, true); } else if (direction == Direction.SOUTHWEST) { SwapTo(X - 1, Y + 1, Z, true); } }
/// <summary> /// 上/下/左/右居中 /// </summary> /// <param name="bound"></param> /// <param name="size"></param> /// <param name="type"></param> /// <returns></returns> public static Rectangle NearCenter(this Rectangle bound, Size size, Direction type) { var _bound = bound; switch (type) { case Direction.Left: _bound.Inflate(0, (size.Height - bound.Height) / 2); _bound.Width = size.Width; break; case Direction.Up: _bound.Inflate((size.Width - bound.Width) / 2, 0); _bound.Height = size.Height; break; case Direction.Right: _bound.Inflate(0, (size.Height - bound.Height) / 2); _bound.X = bound.Right - size.Width; _bound.Width = size.Width; break; case Direction.Bottom: _bound.Inflate((size.Width - bound.Width) / 2, 0); _bound.Y = bound.Bottom - size.Height; _bound.Height = size.Height; break; default: break; } _bound.Intersect(bound); return _bound; }
public Direction[] GetFloorTriangleSlopeDirections() { const float CriticalSlantYComponent = 0.8f; var normals = GetFloorTriangleNormals(); // Initialize slope directions as unslidable by default (EntireFace means unslidable in our case). Direction[] slopeDirections = new Direction[2] { Direction.None, Direction.None }; if (Floor.HasSlope) { for (int i = 0; i < (Floor.IsQuad ? 1 : 2); i++) // If floor is quad, we don't solve second triangle { if (Math.Abs(normals[i].Y) <= CriticalSlantYComponent) // Triangle is slidable { bool angleNotDefined = true; var angle = (float)(Math.Atan2(normals[i].X, normals[i].Z) * (180 / Math.PI)); angle = angle < 0 ? angle + 360.0f : angle; // Note about 45, 135, 225 and 315 degree steps: // Core Design has used override instead of rounding for triangular slopes angled under // 45-degree stride, to produce either east or west-oriented slide. while (angleNotDefined) { switch ((int)angle) { case 0: case 360: slopeDirections[i] = Direction.PositiveZ; angleNotDefined = false; break; case 45: case 90: case 135: slopeDirections[i] = Direction.PositiveX; angleNotDefined = false; break; case 180: slopeDirections[i] = Direction.NegativeZ; angleNotDefined = false; break; case 225: case 270: case 315: slopeDirections[i] = Direction.NegativeX; angleNotDefined = false; break; default: angle = (int)Math.Round(angle / 90.0f, MidpointRounding.AwayFromZero) * 90; break; } } } } // We swap triangle directions for XpZn and XnZp cases, because in these cases // triangle indices are inverted. // For other cases, we move slide direction triangle to proper one accordingly to // step slant value encoded in corner heights. if (Floor.DiagonalSplit != DiagonalSplit.None) { switch (Floor.DiagonalSplit) { case DiagonalSplit.XpZn: slopeDirections[1] = slopeDirections[0]; slopeDirections[0] = Direction.None; break; case DiagonalSplit.XnZp: if (!Floor.IsQuad) { slopeDirections[0] = slopeDirections[1]; slopeDirections[1] = Direction.None; } break; case DiagonalSplit.XnZn: if (Floor.IsQuad) { slopeDirections[1] = slopeDirections[0]; slopeDirections[0] = Direction.None; } else { slopeDirections[0] = Direction.None; } break; case DiagonalSplit.XpZp: if (!Floor.IsQuad) { slopeDirections[1] = Direction.None; } break; } } } return(slopeDirections); }
protected virtual bool ExcludePoint(Point3D p, int range, Direction fromCenter) { return LOSCheck && !Map.LineOfSight(p, Start); }
public void SetRequiredDirection(Direction direction) { requiredDirection = Game.GetDirectionNumber(direction); }
void SwipeHandler(Vector2 swipe) { swipeDirection = GetDirection(swipe); }
void DragHandler(Vector2 swipe) { dragDirection = GetDirection(swipe); }
public static void Walk(GameClient Client, Direction dir) { BeginWalk(Client, dir); EndWalk(Client, dir); }
//Note for this one we just always use checkDirection.LINE here, you can extend it if you like! public InARowEffect(TriggeredEffect e, int n) { onTriggerEffect = e; rowLength = n; checkDirection = Direction.LINE; }
public static void TargetTileRelative(object obj, int distance, bool reverse = false) { int serial = AliasCommands.ResolveSerial(obj); if (serial == 0) { UOC.SystemMessage(Strings.Invalid_or_unknown_object_id); return; } Entity entity = Engine.Mobiles.GetMobile(serial); if (entity == null) { UOC.SystemMessage(Strings.Mobile_not_found___); return; } int x = entity.X; int y = entity.Y; int offsetX = 0; int offsetY = 0; // TODO Direction direction = (Direction)((int)entity.Direction & ~0x80); switch (direction) { case Direction.North: offsetY = -1; break; case Direction.Northeast: offsetY = -1; offsetX = 1; break; case Direction.East: offsetX = 1; break; case Direction.Southeast: offsetX = 1; offsetY = 1; break; case Direction.South: offsetY = 1; break; case Direction.Southwest: offsetY = 1; offsetX = -1; break; case Direction.West: offsetX = -1; break; case Direction.Northwest: offsetX = -1; offsetY = -1; break; case Direction.Invalid: break; default: throw new ArgumentOutOfRangeException(); } int totalOffsetX = offsetX * distance; int totalOffsetY = offsetY * distance; if (reverse) { totalOffsetX = -totalOffsetX; totalOffsetY = -totalOffsetY; } int destinationX = x + totalOffsetX; int destinationY = y + totalOffsetY; Engine.SendPacketToServer(new Target(TargetTypeEnum.Tile, -1, TargetFlags.None, 0, destinationX, destinationY, entity.Z, 0, true)); }
/// <summary> /// Janky hack for keeping the player from moving into an area /// </summary> /// <param name="position"></param> /// <param name="direction">Where this blocker is relative to the screen</param> public DirectionalBlocker(Vector2 position, Direction direction) : base(position) { this.direction = direction; }
/// <summary> /// Return value is true if the player was able to move false when the player couldn't move, such as trying to move into a wall. /// </summary> /// <param name="direction"></param> /// <returns></returns> public bool MovePlayer (Direction direction) { int x = game.Player.X; int y = game.Player.Y; switch (direction) { case Direction.Up: { y = game.Player.Y + 1; break; } case Direction.Down: { y = game.Player.Y - 1; break; } case Direction.Left: { x = game.Player.X - 1; break; } case Direction.Right: { x = game.Player.X + 1; break; } case Direction.UpLeft: { x = game.Player.X - 1; y = game.Player.Y + 1; break; } case Direction.UpRight: { x = game.Player.X + 1; y = game.Player.Y + 1; break; } case Direction.DownLeft: { x = game.Player.X - 1; y = game.Player.Y - 1; break; } case Direction.DownRight: { x = game.Player.X + 1; y = game.Player.Y - 1; break; } default: { return false; } } if (game.World.SetActorPosition (game.Player, x, y)) { return true; } Monster monster = game.World.GetMonsterAt (x, y); if (monster != null) { Attack (game.Player, monster); return true; } return false; }
public static BiDictionary <Opcode, int> GetOpcodeDictionary(ClientVersionBuild build, Direction direction) { switch (GetOpcodeDefiningBuild(build)) { case ClientVersionBuild.V3_3_5a_12340: return(Opcodes_3_3_5.Opcodes(direction)); case ClientVersionBuild.V4_0_3_13329: return(Opcodes_4_0_3.Opcodes(direction)); case ClientVersionBuild.V4_0_6_13596: return(Opcodes_4_0_6.Opcodes(direction)); case ClientVersionBuild.V4_1_0_13914: return(Opcodes_4_1_0.Opcodes(direction)); case ClientVersionBuild.V4_2_0_14333: return(Opcodes_4_2_0.Opcodes(direction)); case ClientVersionBuild.V4_2_2_14545: return(Opcodes_4_2_2.Opcodes(direction)); case ClientVersionBuild.V4_3_0_15005: return(Opcodes_4_3_0.Opcodes(direction)); case ClientVersionBuild.V4_3_2_15211: return(Opcodes_4_3_2.Opcodes(direction)); case ClientVersionBuild.V4_3_3_15354: return(Opcodes_4_3_3.Opcodes(direction)); case ClientVersionBuild.V4_3_4_15595: return(Opcodes_4_3_4.Opcodes(direction)); case ClientVersionBuild.V5_0_4_16016: return(Opcodes_5_0_4.Opcodes(direction)); case ClientVersionBuild.V5_0_5_16048: return(Opcodes_5_0_5.Opcodes(direction)); case ClientVersionBuild.V5_1_0_16309: return(Opcodes_5_1_0.Opcodes(direction)); case ClientVersionBuild.V5_2_0_16650: return(Opcodes_5_2_0.Opcodes(direction)); case ClientVersionBuild.V5_3_0_16981: return(Opcodes_5_3_0.Opcodes(direction)); case ClientVersionBuild.V5_4_0_17359: return(Opcodes_5_4_0.Opcodes(direction)); case ClientVersionBuild.V5_4_1_17538: return(Opcodes_5_4_1.Opcodes(direction)); case ClientVersionBuild.V5_4_2_17658: return(Opcodes_5_4_2.Opcodes(direction)); case ClientVersionBuild.V5_4_7_17898: return(Opcodes_5_4_7.Opcodes(direction)); case ClientVersionBuild.V5_4_8_18291: return(Opcodes_5_4_8.Opcodes(direction)); case ClientVersionBuild.V6_0_2_19033: return(Opcodes_6_0_2.Opcodes(direction)); case ClientVersionBuild.V6_0_3_19103: return(Opcodes_6_0_3.Opcodes(direction)); case ClientVersionBuild.V6_1_0_19678: return(Opcodes_6_1_0.Opcodes(direction)); case ClientVersionBuild.V6_1_2_19802: return(Opcodes_6_1_2.Opcodes(direction)); case ClientVersionBuild.V6_2_0_20173: return(Opcodes_6_2_0.Opcodes(direction)); case ClientVersionBuild.V6_2_2_20444: return(Opcodes_6_2_2.Opcodes(direction)); case ClientVersionBuild.V6_2_3_20726: return(Opcodes_6_2_3.Opcodes(direction)); case ClientVersionBuild.V6_2_4_21315: return(Opcodes_6_2_4.Opcodes(direction)); case ClientVersionBuild.V7_0_3_22248: return(Opcodes_7_0_3.Opcodes(direction)); case ClientVersionBuild.V7_1_0_22900: return(Opcodes_7_1_0.Opcodes(direction)); case ClientVersionBuild.V7_1_5_23360: return(Opcodes_7_1_5.Opcodes(direction)); case ClientVersionBuild.V7_2_0_23706: return(Opcodes_7_2_0.Opcodes(direction)); case ClientVersionBuild.V7_2_5_24330: return(Opcodes_7_2_5.Opcodes(direction)); case ClientVersionBuild.V7_3_0_24920: return(Opcodes_7_3_0.Opcodes(direction)); case ClientVersionBuild.V7_3_2_25383: return(Opcodes_7_3_2.Opcodes(direction)); case ClientVersionBuild.V7_3_5_25848: return(Opcodes_7_3_5.Opcodes(direction)); case ClientVersionBuild.V8_0_1_27101: return(Opcodes_8_0_1.Opcodes(direction)); case ClientVersionBuild.V8_1_0_28724: return(Opcodes_8_1_0.Opcodes(direction)); case ClientVersionBuild.V8_1_5_29683: return(Opcodes_8_1_5.Opcodes(direction)); case ClientVersionBuild.V8_2_0_30898: return(Opcodes_8_2_0.Opcodes(direction)); case ClientVersionBuild.V8_2_5_31921: return(Opcodes_8_2_5.Opcodes(direction)); case ClientVersionBuild.V8_3_0_33062: return(Opcodes_8_3_0.Opcodes(direction)); case ClientVersionBuild.V8_3_7_35249: return(Opcodes_8_3_7.Opcodes(direction)); case ClientVersionBuild.V9_0_1_36216: return(Opcodes_9_0_1.Opcodes(direction)); case ClientVersionBuild.V9_0_2_36639: return(Opcodes_9_0_2.Opcodes(direction)); case ClientVersionBuild.V1_13_2_31446: return(Opcodes_1_13_2.Opcodes(direction)); case ClientVersionBuild.V1_13_4_33598: return(Opcodes_1_13_4.Opcodes(direction)); case ClientVersionBuild.v1_13_5_34713: return(Opcodes_1_13_5.Opcodes(direction)); case ClientVersionBuild.V1_13_6_36714: return(Opcodes_1_13_6.Opcodes(direction)); default: return(Opcodes_3_3_5.Opcodes(direction)); } }
public ClampedScrollbar(Direction direction) : base(direction) { }
public static OrderBy Create(string field, Direction direction) { return(new OrderBy(direction.ToFriendlyString(), field)); }
public IAsyncEnumerable <IReadOnlyCollection <RestMessage> > GetMessagesAsync(IMessage fromMessage, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch, RequestOptions options = null) => ChannelHelper.GetMessagesAsync(this, Discord, fromMessage.Id, dir, limit, options);
internal Bullet(int x, int y, int width, int height, Direction direction) : base(x, y, width, height) { this.Direction = direction; }
public PrimaryKeyColumnRef(SecondaryIndexInfo parent, ColumnInfo column, Direction direction) : base(parent, column, direction) { }
protected override ScrollbarContainer CreateScrollbar(Direction direction) => new ClampedScrollbar(direction);
public virtual Port InstantiatePort(Orientation orientation, Direction direction, Port.Capacity capacity, Type type) { return(Port.Create <Edge>(orientation, direction, capacity, type)); }
public MagicRequest(Type type, Direction direction) { this.type = type; this.direction = direction; }
/// <summary> /// Record that the ship is now deployed. /// </summary> /// <param name="direction"></param> /// <param name="row"></param> /// <param name="col"></param> internal void Deployed(Direction direction, int row, int col) { _row = row; _col = col; _direction = direction; }
IAsyncEnumerable <IReadOnlyCollection <IMessage> > IMessageChannel.GetMessagesAsync(IMessage fromMessage, Direction dir, int limit, CacheMode mode, RequestOptions options) { if (mode == CacheMode.AllowDownload) { return(GetMessagesAsync(fromMessage, dir, limit, options)); } else { return(AsyncEnumerable.Empty <IReadOnlyCollection <IMessage> >()); } }