public Cursor Move(Buffer buf, MoveDirection direction)
{
switch (direction)
{
case MoveDirection.Up:
if (AtFirstLine(buf))
return new Cursor(0, 0);
else
return new Cursor(Line - 1, Math.Min(Column, buf.Lines[Line - 1].Data.Length));
case MoveDirection.Down:
if (AtLastLine(buf))
return new Cursor(Line, buf.Lines[Line].Data.Length);
else
return new Cursor(Line + 1, Math.Min(Column, buf.Lines[Line + 1].Data.Length));
case MoveDirection.Left:
if (AtStart(buf))
return this;
else if (AtFirstColumn(buf))
return new Cursor(Line - 1, buf.Lines[Line - 1].Data.Length);
else
return new Cursor(Line, Column - 1);
case MoveDirection.Right:
if (AtEnd(buf))
return this;
else if (AtLastColumn(buf))
return new Cursor(Line + 1, 0);
else
return new Cursor(Line, Column + 1);
}
return this;
}
private void PrepareLookResult(MoveDirection direction, int distance)
{
if (distance == 0) {
lookResult [direction].Clear ();
lookResult [direction].Add (lookable.Look (pov));
} else {
if (lookResult [direction].Count < distance)
PrepareLookResult (direction, distance - 1);
pointsInDirectionCache [direction] =
pov.LookInDirection (direction, distance, pointsInDirectionCache [direction]);
Point[] pointsToCount = pointsInDirectionCache [direction] [distance];
int result = 0;
foreach (Point p in pointsToCount)
result += lookable.Look (p);
lookResult [direction].Add (result + lookResult [direction] [distance - 1]);
}
}
protected virtual void Move(MoveDirection direction)
{
switch (direction) {
case MoveDirection.Down:
MoveDown ();
break;
case MoveDirection.Left:
MoveLeft ();
break;
case MoveDirection.Right:
MoveRight ();
break;
case MoveDirection.Up:
MoveUp ();
break;
default:
// just chill!
break;
}
}
private Vector2 _NewPosition; // So we don't have to redefine the variable each time. Player nicer with the Garbage Collect.
#endregion Fields
#region Methods
/// <summary>
/// Move Object
/// </summary>
/// <param name="Direction"></param>
private void Move(MoveDirection Direction)
{
// Assign appropriate movement base on input key.
switch (Direction)
{
case MoveDirection.Up:
_NewPosition = new Vector2(transform.position.x, transform.position.y + _MovementValue);
break;
case MoveDirection.Left:
_NewPosition = new Vector2(transform.position.x - _MovementValue, transform.position.y);
break;
case MoveDirection.Down:
_NewPosition = new Vector2(transform.position.x, transform.position.y - _MovementValue);
break;
case MoveDirection.Right:
_NewPosition = new Vector2(transform.position.x + _MovementValue, transform.position.y);
break;
default:
_NewPosition = transform.position;
break;
}
// Finally, update our position.
transform.position = Vector3.Lerp(transform.position, _NewPosition, Time.deltaTime);
}
private void Move(MoveDirection direction)
{
MoveCommand moveCommand = new MoveCommand(moveCommandReciever, direction, moveDistance, objectToMove);
moveCommand.Execute();
commands.Add(moveCommand);
currentCommandNum++;
}
public void Fire(Vector2 theStartPosition, Vector2 theSpeed, Vector2 theDirection, MoveDirection playerDirection, TimeSpan gameTime)
{
_direction = playerDirection;
if (playerDirection == MoveDirection.Right)
Position = new Vector2(theStartPosition.X - 80, theStartPosition.Y);
else
Position = new Vector2(theStartPosition.X - 50, theStartPosition.Y);
StartPosition = theStartPosition;
mSpeed = theSpeed;
mDirection = theDirection;
if (Data.Effect == ProjectileEffect.Burn)
{
mSpeed.X = 0;
if (_direction == MoveDirection.Left)
{
int width = SpriteTexture.Width / Columns;
if (playerDirection == MoveDirection.Right)
Position = new Vector2(theStartPosition.X - 80, theStartPosition.Y);
else
Position = new Vector2(theStartPosition.X - 50 - width, theStartPosition.Y);
}
_burnStart = gameTime;
}
}
public override void Move(MoveDirection dir)
{
Position to;
switch (dir)
{
case MoveDirection.UpLeft:
to = new Position(Pos.Row - 1, Pos.Col - 1);
break;
case MoveDirection.UpRight:
to = new Position(Pos.Row - 1, Pos.Col + 1);
break;
case MoveDirection.DownLeft:
to = new Position(Pos.Row + 1, Pos.Col - 1);
break;
case MoveDirection.DownRight:
to = new Position(Pos.Row + 1, Pos.Col + 1);
break;
default: // Should cover all cases
return;
}
if (!_board.IsValidPosition(to))
return;
Move m = new Move(Pos, to);
_board.Move(m);
Pos = to;
}
public bool Move(MoveDirection movedirection)
{
bool moved = false;
if (!isOutsideOfSea(movedirection))
{
switch (movedirection)
{
case MoveDirection.Left:
foreach (Block b in this.blocks)
b.xPos -= 1;
break;
case MoveDirection.Right:
foreach (Block b in this.blocks)
b.xPos += 1;
break;
case MoveDirection.Up:
foreach (Block b in this.blocks)
b.yPos -= 1;
break;
case MoveDirection.Down:
foreach (Block b in this.blocks)
b.yPos += 1;
break;
default:
break;
}
}
return moved;
}
public void Move(MoveDirection direction)
{
switch (direction)
{
case MoveDirection.Up:
this.RemoveFromPreviousPosition();
this.posY -= 1;
this.Draw();
break;
case MoveDirection.Down:
this.RemoveFromPreviousPosition();
this.posY += 1;
this.Draw();
break;
case MoveDirection.Left:
this.RemoveFromPreviousPosition();
this.posX -= 1;
this.Draw();
break;
case MoveDirection.Right:
this.RemoveFromPreviousPosition();
this.posX += 1;
this.Draw();
break;
default:
break;
}
this.direct = direction;
}
public void Move(MoveDirection direction)
{
if(this.OnMoveReceived != null)
{
this.OnMoveReceived(direction, new MoveEventArgs());
}
}
private bool CanMoveInDirection(Position position, MoveDirection direction)
{
if (direction == MoveDirection.Up &&
position.Row <= 0)
{
return false;
}
if (direction == MoveDirection.Down &&
position.Row >= BOARD_SIZE - 1)
{
return false;
}
if (direction == MoveDirection.Left &&
position.Column <= 0)
{
return false;
}
if (direction == MoveDirection.Right &&
position.Column >= BOARD_SIZE - 1)
{
return false;
}
Position newPosition = CalculatePositionWithDirection(position, direction);
if (this.matrix[newPosition.Row, newPosition.Column] != " ")
{
return false;
}
return true;
}
//Constructor
public MoveCommand(MoveCommandReceiver reciever, MoveDirection direction, float distance, GameObject gameObjectToMove)
{
this._receiver = reciever;
this._direction = direction;
this._distance = distance;
this._gameObject = gameObjectToMove;
}
public Point GetNewLocation(Point oldLocation, MoveDirection? direction)
{
var newLocation = new Point(oldLocation.X, oldLocation.Y);
if (direction == null)
{
return newLocation;
}
switch (direction)
{
case MoveDirection.Up:
newLocation.Y--;
break;
case MoveDirection.Down:
newLocation.Y++;
break;
case MoveDirection.Right:
newLocation.X++;
break;
case MoveDirection.Left:
newLocation.X--;
break;
}
return newLocation;
}
public Vector2 Move( MoveDirection move ) {
switch( move ) {
case MoveDirection.Up:
this.playerPosition.Y--;
currentDirection = MoveDirection.Up;
break;
case MoveDirection.Down:
this.playerPosition.Y++;
currentDirection = MoveDirection.Down;
break;
case MoveDirection.Left:
this.playerPosition.X--;
currentDirection = MoveDirection.Left;
break;
case MoveDirection.Right:
this.playerPosition.X++;
currentDirection = MoveDirection.Right;
break;
default:
currentDirection = MoveDirection.Idle;
break;
}
center.X = playerPosition.X + 11;
center.Y = playerPosition.Y + 11;
return new Vector2( 0, 0 );
}
public void Jump(MoveDirection inputDirection)
{
if (isOnGround)
{
Vector2 force;
if (inputDirection == MoveDirection.Right)
{
force.x = Vector2.right.x * jumpForce.x;
}
else if (inputDirection == MoveDirection.Left)
{
force.x = Vector2.left.x * jumpForce.x;
}
else
{
force.x = 0;
}
force.y = jumpForce.y;
m_Body.AddForce(force);
m_AnimationController.SetFloat("JumpDirection", force.x);
m_AnimationController.SetTrigger("Jump");
}
}
public void RequestMove(MoveDirection direction)
{
//-- get the tile in the direction
TileScript nextTile = levelManager.GetTile(direction, m_CurrentTile.myLaneNumber, m_CurrentTile.myElevation);
//if( nextTile.myTileType != TileType.Blocker )
if (nextTile != null)
{
if (direction == MoveDirection.MoveUp)
{
m_PlayerController.SetPlayerState(PlayerState.Hop_Up);
levelManager.MoveTiles(MoveDirection.MoveUp, playerMoveTime);
}
if (direction == MoveDirection.MoveDown)
{
m_PlayerController.SetPlayerState(PlayerState.Hop_Down);
levelManager.MoveTiles(MoveDirection.MoveDown, playerMoveTime);
}
if (direction == MoveDirection.MoveLeft)
{
m_PlayerController.SetPlayerState(PlayerState.Hop_Left);
}
if (direction == MoveDirection.MoveRight)
{
m_PlayerController.SetPlayerState(PlayerState.Hop_Right);
}
//-- let the player controller know we are preparing to switch ik targets
m_PlayerController.SetNextIKSet(nextTile.ikTarget);
//-- cache the current tile
m_CurrentTile = nextTile;
}
}
/// <summary>
/// アカウントの並び順を変更します。
/// </summary>
/// <param name="elem">対象アカウント</param>
/// <param name="dir">移動先</param>
public static void MoveAccountElement(string id, MoveDirection dir)
{
var elem = GetAccountElement(id);
if(elem==null)return;
var idx = accountModels.IndexOf(elem);
if (idx < 0) return;
switch (dir)
{
case MoveDirection.Up:
if (idx > 0)
{
accountModels.RemoveAt(idx);
accountModels.Insert(idx - 1, elem);
}
break;
case MoveDirection.Down:
if (idx < accountModels.Count - 1)
{
accountModels.RemoveAt(idx);
accountModels.Insert(idx + 1, elem);
}
break;
default:
throw new ArgumentException("移動方向指定がちゃんちゃらおかしい :" + dir.ToString());
}
AccountsChanged();
}
void Update()
{
var v = Input.GetAxis("Vertical");
var h = Input.GetAxis("Horizontal");
MoveDirection md = _GetMoveDirection(v , h);
if (md != _Current)
{
MoveCommandParam mcp = _GetMoveCommandParam(md);
_Current = md;
if (mcp.ActionStatus == Regulus.Project.TurnBasedRPG.ActionStatue.Idle)
{
_GamePlayer.Stop(mcp.Direction);
}
else
{
_GamePlayer.Walk(mcp.Direction);
}
}
}
public override Projectile[] Shoot( MoveDirection direction, Microsoft.Xna.Framework.Vector2 startPos )
{
if ( fireRate-- > 0 )
return new Projectile[0];
fireRate = FireRate;
return new[] { new Bullet( startPos, direction ) };
}
public static Point MoveDirectionConvertToPoint(MoveDirection dire)
{
Point offsetPos = new Point();
switch (dire)
{
case MoveDirection.Left:
offsetPos = new Point(-1, 0);
break;
case MoveDirection.Right:
offsetPos = new Point(1, 0);
break;
case MoveDirection.Up:
offsetPos = new Point(0, -1);
break;
case MoveDirection.Down:
offsetPos = new Point(0, 1);
break;
case MoveDirection.LeftUp:
offsetPos = new Point(-1, -1);
break;
case MoveDirection.LeftDown:
offsetPos = new Point(-1, 1);
break;
case MoveDirection.RightUp:
offsetPos = new Point(1, -1);
break;
case MoveDirection.RightDown:
offsetPos = new Point(1, 1);
break;
default:
break;
}
return offsetPos;
}
public GameState MakeMove(MoveDirection direction)
{
_BoardWriter.Clear();
if (!_Board.CanMoveInDirection(direction))
{
_BoardWriter.WriteBoard(_Board);
_BoardWriter.WriteMessage("No available moves in that direction.");
}
else
{
_Board.Move(direction);
_Board.PlaceRandomCell();
_BoardWriter.WriteBoard(_Board);
}
var gameState = CheckGameState();
if (gameState == GameState.Won)
{
_BoardWriter.WriteMessage("You won! Or there was a severe programming error.");
}
else if (gameState == GameState.Lost)
{
_BoardWriter.WriteMessage("No more moves! Game over man! Game over!");
}
return gameState;
}
/// <summary>
/// All logic about collision and physics is kept here.
/// </summary>
public static bool ObjectCollisionDetector(IMoveable moveableObject, MoveDirection moveDirection, out GameObject collisionObj)
{
Vector2 currentPosition = moveableObject.Position;
float x = currentPosition.X;
float y = currentPosition.Y;
switch (moveDirection)
{
case MoveDirection.Up:
y -= moveableObject.Speed;
break;
case MoveDirection.Down:
y += moveableObject.Speed;
break;
case MoveDirection.Left:
x -= moveableObject.Speed;
break;
case MoveDirection.Right:
x += moveableObject.Speed;
break;
}
Rectangle futureBounds = new Rectangle((int)x, (int)y, moveableObject.Bounds.Width, moveableObject.Bounds.Height);
foreach (GameObject gameObject in ObjectFactory.AllObjects.Where(obj => !(obj is Player)))
{
if (futureBounds.Intersects(gameObject.Bounds))
{
if (moveableObject is Player)
{
collisionObj = gameObject;
Console.WriteLine("collision detected!");
return true;
}
if (moveableObject is NPC)
{
if (gameObject is NPC)
{
collisionObj = gameObject;
return false;
}
else if (gameObject is Player)
{
collisionObj = gameObject;
return true;
}
}
}
}
if (futureBounds.X <= 0 ||
!(futureBounds.X + futureBounds.Width <= Constants.WINDOW_DEFAULT_WIDTH) ||
futureBounds.Y <= 0 ||
futureBounds.Y + futureBounds.Height >= Constants.WINDOW_DEFAULT_HEIGHT)
{
collisionObj = ObjectFactory.PLAYER;
Console.WriteLine("Collision detected at ({0},{1})", futureBounds.X, futureBounds.Y);
return true;
}
collisionObj = null;
return false;
}
public MoveDirection CanMove(float gameWindowWidth, float gameWindowHeight, MoveDirection playerMoveDirection)
{
var _MaxX = gameWindowWidth - (Size.Width / Columns ) - 100;
var _MinX = 100;
var _MaxY = gameWindowHeight - Size.Height - 100;
var _MinY = 0;
// Check for bounce.
if (Position.X > _MaxX)
{
if (playerMoveDirection == MoveDirection.Right)
return MoveDirection.Stop;
}
else if (Position.X < _MinX)
{
if (playerMoveDirection == MoveDirection.Left)
return MoveDirection.Stop;
}
if (Position.Y > _MaxY)
{
if (playerMoveDirection == MoveDirection.Up)
return MoveDirection.Stop;
}
else if (Position.Y < _MinY)
{
if (playerMoveDirection == MoveDirection.Down)
return MoveDirection.Stop;
}
return playerMoveDirection;
}
public void FillPathVolume(MoveDirection dir, int step)
{
int index = 0;
while (index <= step) {
pathFillers.Add((GameObject)Instantiate(invisibleObstacle, transform.position + dir.AsVector() * index, transform.rotation));
++index;
}
}
public static void ChangeOrder(int DeptID, int priorityId, MoveDirection direction)
{
UpdateData("sp_UpdatePriorityOrder", new SqlParameter[]{
new SqlParameter("@DepartmentId", DeptID),
new SqlParameter("@PriorityId", priorityId),
new SqlParameter("@MoveUp", (int)direction)
});
}
// implement movement interface
public void PlayerMovement(MoveDirection moveDirection)
{
//see if need to flip the direction
if(moveDirection != MoveDirection.NONE && computerLane == ComputerLane.LEFT){
int newDirection = ((int) moveDirection + 4 ) % 8;
moveDirection = (MoveDirection) newDirection;
}
this.moveDirection = moveDirection;
}
public SimpleStarBehaviour(ICatchable obj)
{
this.catchable = obj;
this.obj = obj.GameObject.transform;
this.sea = obj.Sea;
// this.speed = obj.GameObject.GetComponent<Fish>().speed;
this.moveDirection = (UnityEngine.Random.Range (0, 2) == 1 ? MoveDirection.Up : MoveDirection.Down);
}
void FindPathToTarget()
{
// TODO intelligent pathfinding
if (target.position.x > this.transform.position.x) {
moveDirection = MoveDirection.RIGHT;
} else {
moveDirection = MoveDirection.LEFT;
}
}
public void SnakeMoveInEachDirectionCorrect(MoveDirection changeDirection, int resultX, int resultY)
{
var snake = new Snake(1, 1);
snake.ChangeDirection(changeDirection);
snake.Move();
Assert.IsTrue(snake.Head.X == resultX);
Assert.IsTrue(snake.Head.Y == resultY);
Assert.IsNull(snake.Head.Next);
}
internal BattleSnake GetTailOwner(BattleSnake snake, MoveDirection moveDirection)
{
//var coordinates = GetRelativeToMoveDirectionCoordinates(snake, moveDirection); //translate relative coordinates to absolute
//var tailOwner = snakes.Where(snake => snake.Tail.Coordinates == coordinates).SingleOrDefault():
/*
* return tailOwner;
*/
throw new NotImplementedException();
}
public MotorDirectionChangedEventArgs(MoveDirection direction)
{
Direction = direction;
}
internal MoveBlockBuilderViewModel()
{
currentDirection = MoveDirection.Forward;
Speed = 80;
DirectionOptions = Enum.GetNames(typeof(MoveDirection));
}
public void BindUnidirectional(GameObject source, GameObject target, MoveDirection direction,
Func <bool> condition = null)
{
AddBinding(source, target, direction, false, condition);
}
public void BindBidirectional(Component source, Component target, MoveDirection direction,
Func <bool> condition = null, Func <bool> backwardCondition = null)
{
BindBidirectional(source.gameObject, target.gameObject, direction, condition, backwardCondition);
}
public MoveSelect(Selection tool, string id, MoveDirection direction, Keys modifier, Keys accelerator)
: base(tool.Handler, id, direction, accelerator | modifier)
{
this.tool = tool;
this.ID += "_Select";
}
public void SetUp()
{
_grid = new Grid(4, 4, new Position(0, 0));
_directionMove = new DirectionMove(_grid);
direction = MoveDirection.North;
}
public WalkByDirection(MoveDirection defaultDirection)
{
currentDirection = defaultDirection;
}
/// <summary>
/// Moves the head based on direction and speed
/// </summary>
/// <remarks>Requires behavior control; see <see cref="ControlComponent.RequestControl(int)"/>.</remarks>
/// <param name="moveDirection">The move direction.</param>
/// <param name="speed">The speed.</param>
/// <returns>A task that represents the asynchronous operation; the task result contains the result from the robot.</returns>
public async Task <StatusCode> MoveHead(MoveDirection moveDirection, MotorSpeed speed = MotorSpeed.Medium)
{
float headSpeed = PickSpeed(speed, 0.5f, 1, 2);
return(await SetHeadMotor((float)moveDirection *headSpeed).ConfigureAwait(false));
}
public void test_that_position_in_the_Middle_of_Chessboard_Is_available_for_all_moves(int column, int row, MoveDirection moveDirection)
{
var board = new Board(cols, rows, new List <Tuple <int, int> >());
var actual = board.IsMoveAvailable(new BoardPosition(column, row), moveDirection);
Assert.IsTrue(actual);
}
public HashSet <Selectable> GetUITargets(GraphicRaycaster gRay, PointerEventData pD)
{
if (cam != gRay.eventCamera)
{
cam = gRay.eventCamera;
}
aD.Reset();
aD.moveVector = (this.pD.position - pD.position);
float x1 = this.pD.position.x,
x2 = pD.position.x,
y1 = this.pD.position.y,
y2 = pD.position.y;
float xDiff = x1 - x2;
float yDiff = y1 - y2;
MoveDirection dir = MoveDirection.None;
if (xDiff > yDiff)
{
if (xDiff > 0f)
{
dir = MoveDirection.Right;
}
else if (xDiff < 0f)
{
dir = MoveDirection.Left;
}
else if (yDiff > xDiff)
{
if (yDiff > 0f)
{
dir = MoveDirection.Up;
}
else if (yDiff < 0f)
{
dir = MoveDirection.Down;
}
}
}
aD.moveDir = dir;
var ray = cam.ScreenPointToRay(pD.position);
Debug.DrawRay(ray.origin, ray.direction * 10, Color.yellow);
List <RaycastResult> hits = new List <RaycastResult>();
HashSet <Selectable> uibT = new HashSet <Selectable>();
gRay.Raycast(pD, hits);
if (hits.Count > 0)
{
pD.pointerCurrentRaycast = pD.pointerPressRaycast = hits[0];
}
for (int i = 0; i < hits.Count; i++)
{
var go = hits[i].gameObject;
Selectable u = GOGetter(go);
if (u)
{
uibT.Add(u);
}
}
this.pD = pD;
return(uibT);
}
private void OnMove(MoveDirection direction)
{
moveDirection = direction;
}
private void ForceMove(MoveDirection dir)
{
List <MoveDirection> otherdir = new List <MoveDirection>();
if (dir != MoveDirection.up)
{
otherdir.Add(MoveDirection.up);
}
if (dir != MoveDirection.down)
{
otherdir.Add(MoveDirection.down);
}
if (dir != MoveDirection.left)
{
otherdir.Add(MoveDirection.left);
}
if (dir != MoveDirection.right)
{
otherdir.Add(MoveDirection.right);
}
bool forcechanged;
for (int n = 0; n < 3; n++)
{
int a = Convert.ToInt32(r.NextDouble() * otherdir.Count - .5);
forcechanged = false;
switch (otherdir[a])
{
case MoveDirection.up:
for (int y = 1; y < Height; y++)
{
for (int x = 0; x < Width; x++)
{
MoveTile(x, y, 0, -y, forcechanged, out forcechanged);
}
}
break;
case MoveDirection.down:
for (int y = Height - 2; y >= 0; y--)
{
for (int x = 0; x < Width; x++)
{
MoveTile(x, y, 0, (Height - 1) - y, forcechanged, out forcechanged);
}
}
break;
case MoveDirection.left:
for (int x = 1; x < Width; x++)
{
for (int y = 0; y < Height; y++)
{
MoveTile(x, y, -x, 0, forcechanged, out forcechanged);
}
}
break;
case MoveDirection.right:
for (int x = Width - 2; x >= 0; x--)
{
for (int y = 0; y < Height; y++)
{
MoveTile(x, y, (Width - 1) - x, 0, forcechanged, out forcechanged);
}
}
break;
}
if (forcechanged)
{
ChangedThisMove = true;
return;
}
otherdir.RemoveAt(a);
}
}
private MoveAction(MoveDirection direction)
{
Direction = direction;
}
public void Move(MoveDirection dir)
{
LastMove = dir;
ChangedThisMove = false;
switch (dir)
{
case MoveDirection.up:
for (int y = 1; y < Height; y++)
{
for (int x = 0; x < Width; x++)
{
MoveTile(x, y, 0, -y);
}
}
break;
case MoveDirection.down:
for (int y = Height - 2; y >= 0; y--)
{
for (int x = 0; x < Width; x++)
{
MoveTile(x, y, 0, (Height - 1) - y);
}
}
break;
case MoveDirection.left:
for (int x = 1; x < Width; x++)
{
for (int y = 0; y < Height; y++)
{
MoveTile(x, y, -x, 0);
}
}
break;
case MoveDirection.right:
for (int x = Width - 2; x >= 0; x--)
{
for (int y = 0; y < Height; y++)
{
MoveTile(x, y, (Width - 1) - x, 0);
}
}
break;
}
if (DoForceMove && !ChangedThisMove)
{
ForceMove(dir);
}
if (ChangedThisMove)
{
BadMovesTillLose = BadMovesTillLoseMax;
DoForceMove = false;
EmptyTiles = new List <Point>();
for (int x = 0; x < Width; x++)
{
for (int y = 0; y < Height; y++)
{
if (Grid[x, y] == 0)
{
EmptyTiles.Add(new Point(x, y));
}
}
}
int n = Convert.ToInt32(r.NextDouble() * EmptyTiles.Count - 0.5);
Grid[EmptyTiles[n].X, EmptyTiles[n].Y] = r.NextDouble() > 0.9 ? 4 : 2;
EmptyCount = EmptyTiles.Count - 1;
}
else
{
BadMovesTillLose--;
DoForceMove = true;
if (BadMovesTillLose == 0)
{
Lose();
}
}
}
public override void Move(MoveDirection direction)
{
throw new System.NotImplementedException();
}
public Trigger(TriggerType Type, MoveDirection EnterDirection, Image image, int Layer, bool HasCollision, RectangleF collision, bool DrawAsSprite, bool AnimateImage) : base(image, Layer, HasCollision, collision, DrawAsSprite, AnimateImage)
{
this.Type = Type;
this.EnterDirection = EnterDirection;
}
// 1フレームに1回呼ばれる更新メソッド
private void Update()
{
// 移動中フラグ
bool moveFlag = false;
// 弾連続生成のクールタイムに加算
nowCoolTime += Time.deltaTime;
// 左移動チェック。弾の発射モーション中は移動できない
if (Input.GetKey(KeyCode.LeftArrow) && !bulletAnimation)
{
// 左に移動しているので、移動状態を設定
moveFlag = true;
nowDirection = MoveDirection.Left;
// 体の向いている角度を直指定する
this.gameObject.transform.localEulerAngles = new Vector3(0, 90, 0);
// 座標は計算してから入れる
Vector3 nowPosition = this.gameObject.transform.localPosition;
// 地面の左端より遠くに行かないように監視
if (nowPosition.x > -(groundObject.transform.localScale.x / 2f))
{
nowPosition -= new Vector3(moveSpeed, 0, 0);
this.gameObject.transform.localPosition = nowPosition;
}
}
// 右移動チェック。弾の発射モーション中は移動できない
if (Input.GetKey(KeyCode.RightArrow) && !bulletAnimation)
{
// 右に移動しているので、移動状態を設定
moveFlag = true;
nowDirection = MoveDirection.Right;
// 角度を直指定する
this.gameObject.transform.localEulerAngles = new Vector3(0, -90, 0);
// 座標は計算してから入れる
Vector3 nowPosition = this.gameObject.transform.localPosition;
// 地面の右端より遠くに行かないように監視
if (nowPosition.x < (groundObject.transform.localScale.x / 2f))
{
nowPosition += new Vector3(moveSpeed, 0, 0);
this.gameObject.transform.localPosition = nowPosition;
}
}
// 腕と足回転クラスに移動フラグをアニメーションフラグとして渡す
rotAnimation.SetAnimationFlag(moveFlag);
// スペースキーと向きチェック。発射間隔や発射モーションの状態も考慮する
if (Input.GetKey(KeyCode.Space) && (nowDirection != MoveDirection.None) &&
(nowCoolTime >= bulletCoolTime) && !bulletAnimation)
{
// 弾の再生性までの時間を適応
nowCoolTime = 0f;
// 弾発射モーションフラグをON
bulletAnimation = true;
// 弾の発射アニメーションを開始する
StartCoroutine(StartBulletAnimation());
}
}
public Trigger(TriggerType Type, MoveDirection EnterDirection, Image image, int Layer, bool HasCollision, PointF pt, bool DrawAsSprite) : base(image, Layer, HasCollision, pt, DrawAsSprite, false)
{
this.Type = Type;
this.EnterDirection = EnterDirection;
}
public void BindBidirectional(GameObject source, GameObject target, MoveDirection direction,
Func <bool> condition = null, Func <bool> backwardCondition = null)
{
AddBinding(source, target, direction, true, condition, backwardCondition ?? condition);
}
public Trigger_Change_Layer(TriggerType Type, MoveDirection EnterDirection, int LayerToChangeTo, Image image, int Layer, bool HasCollision, RectangleF collision, bool DrawAsSprite, bool AnimateImage) : base(Type, EnterDirection, image, Layer, HasCollision, collision, DrawAsSprite, AnimateImage)
{
this.LayerToChangeTo = LayerToChangeTo;
}
/// <summary>
/// Adjust the selected item and range based on keyboard input.
/// This is used to override the listview behavious for up/down arrow manipulation vs left/right for a horizontal control
/// </summary>
/// <param name="direction">direction to move the selection</param>
/// <returns>True if the focus was moved, false otherwise</returns>
private bool MoveFocusAndSelection(MoveDirection direction)
{
bool retVal = false;
var currentContainerItem = FocusManager.GetFocusedElement() as TokenizingTextBoxItem;
if (currentContainerItem != null)
{
var currentItem = ItemFromContainer(currentContainerItem);
var previousIndex = Items.IndexOf(currentItem);
var index = previousIndex;
if (direction == MoveDirection.Previous)
{
if (previousIndex > 0)
{
index -= 1;
}
else
{
if (TabNavigateBackOnArrow)
{
FocusManager.TryMoveFocus(FocusNavigationDirection.Previous);
}
retVal = true;
}
}
else if (direction == MoveDirection.Next)
{
if (previousIndex < Items.Count - 1)
{
index += 1;
}
}
// Only do stuff if the index is actually changing
if (index != previousIndex)
{
var newItem = ContainerFromIndex(index) as TokenizingTextBoxItem;
// Check for the new item being a text control.
// this must happen before focus is set to avoid seeing the caret
// jump in come cases
if (Items[index] is PretokenStringContainer && !IsShiftPressed)
{
newItem._autoSuggestTextBox.SelectionLength = 0;
newItem._autoSuggestTextBox.SelectionStart = direction == MoveDirection.Next
? 0
: newItem._autoSuggestTextBox.Text.Length;
}
newItem.Focus(FocusState.Keyboard);
// if no control keys are selected then the selection also becomes just this item
if (IsShiftPressed)
{
// What we do here depends on where the selection started
// if the previous item is between the start and new position then we add the new item to the selected range
// if the new item is between the start and the previous position then we remove the previous position
int newDistance = Math.Abs(SelectedIndex - index);
int oldDistance = Math.Abs(SelectedIndex - previousIndex);
if (newDistance > oldDistance)
{
SelectedItems.Add(Items[index]);
}
else
{
SelectedItems.Remove(Items[previousIndex]);
}
}
else if (!IsControlPressed)
{
SelectedIndex = index;
// This looks like a bug in the underlying ListViewBase control.
// Might need to be reviewed if the base behaviour is fixed
// When two consecutive items are selected and the navigation moves between them,
// the first time that happens the old focused item is not unselected
if (SelectedItems.Count > 1)
{
SelectedItems.Clear();
SelectedIndex = index;
}
}
retVal = true;
}
}
return(retVal);
}
public Trigger_Change_Layer(TriggerType Type, MoveDirection EnterDirection, int LayerToChangeTo, Image image, int Layer, bool HasCollision, PointF pt, bool DrawAsSprite) : base(Type, EnterDirection, image, Layer, HasCollision, pt, DrawAsSprite, false)
{
this.LayerToChangeTo = LayerToChangeTo;
}
private void TryMove(MoveDirection moveDirection)
{
Debug.Log(moveDirection);
}
public Trigger_Damage(int Damage, TriggerType Type, MoveDirection EnterDirection, Image image, int Layer, bool HasCollision, RectangleF collision, bool DrawAsSprite, bool AnimateImage) : base(Type, EnterDirection, image, Layer, HasCollision, collision, DrawAsSprite, AnimateImage)
{
}
public IEnumerator MoveCoroutine(MoveDirection md)
{
State = GameState.WaitingForMoveToEnd;
bool MovedUp = false;
//start moving each line with delays depending on MoveDirection md
switch (md)
{
case MoveDirection.Down:
for (int i = 0; i < columns.Count; i++)
{
MoveOneLineUpIndexCoroutineIdentifier = MoveOneLineUpIndexCoroutine(columns [i], i);
StartCoroutine(MoveOneLineUpIndexCoroutineIdentifier);
MovedUp = true;
}
break;
case MoveDirection.Left:
for (int i = 0; i < rows.Count; i++)
{
MoveOneLineDownIndexCoroutineIdentifier = MoveOneLineDownIndexCoroutine(rows [i], i);
StartCoroutine(MoveOneLineDownIndexCoroutineIdentifier);
}
break;
case MoveDirection.Right:
for (int i = 0; i < rows.Count; i++)
{
MoveOneLineUpIndexCoroutineIdentifier = MoveOneLineUpIndexCoroutine(rows [i], i);
StartCoroutine(MoveOneLineUpIndexCoroutineIdentifier);
MovedUp = true;
}
break;
case MoveDirection.Up:
for (int i = 0; i < columns.Count; i++)
{
MoveOneLineDownIndexCoroutineIdentifier = MoveOneLineDownIndexCoroutine(columns [i], i);
StartCoroutine(MoveOneLineDownIndexCoroutineIdentifier);
}
break;
}
// Wait until the move is over in all lines
while (!(lineMoveComplete [0] && lineMoveComplete [1] && lineMoveComplete [2] && lineMoveComplete [3]))
{
yield return(null);
}
if (moveMade)
{
UpdateEmptyTiles();
Generate();
if (!CanMove())
{
GameOver();
}
}
State = GameState.Playing;
StopCoroutine(MoveCoroutineIdentifier);
if (MovedUp)
{
StopCoroutine(MoveOneLineUpIndexCoroutineIdentifier);
}
else
{
StopCoroutine(MoveOneLineDownIndexCoroutineIdentifier);
}
}
public Trigger_Damage(int Damage, TriggerType Type, MoveDirection EnterDirection, Image image, int Layer, bool HasCollision, PointF pt, bool DrawAsSprite) : base(Type, EnterDirection, image, Layer, HasCollision, pt, DrawAsSprite, false)
{
}
/// <summary>
/// Moves the lift based on direction and speed
/// </summary>
/// <remarks>Requires behavior control; see <see cref="ControlComponent.RequestControl(int)"/>.</remarks>
/// <param name="moveDirection">The move direction.</param>
/// <param name="speed">The speed.</param>
/// <returns>A task that represents the asynchronous operation.</returns>
public async Task <StatusCode> MoveLift(MoveDirection moveDirection, MotorSpeed speed = MotorSpeed.Medium)
{
float liftSpeed = PickSpeed(speed, 2, 4, 8);
return(await SetLiftMotor((float)moveDirection *liftSpeed).ConfigureAwait(false));
}
public async Task DoMove(MoveDirection direction)
{
if (bot.Energy > MainGame.Settings.EnergyLostByMove)
{
bot.Energy -= MainGame.Settings.EnergyLostByMove;
}
else
{
bot.Energy = 0;
}
int x = 0;
int y = 0;
switch (direction)
{// TODO: check if it is ok for east/west. Ok for north/south
// pour l'instant, on se déplace haut/bas/gauche/droite, pas de diagonale
case MoveDirection.North: y = 1; break;
case MoveDirection.South: y = -1; break;
case MoveDirection.East: x = -1; break;
case MoveDirection.West: x = 1; break;
/*case MoveDirection.NorthWest: y = 1; x = 1; break;
* case MoveDirection.NorthEast: y = 1; x = -1; break;
* case MoveDirection.SouthWest: y = -1; x = 1; break;
* case MoveDirection.SouthEast: y = -1; x = -1; break;
*/
}
switch (MainGame.TheMap[bot.X + x, bot.Y + y])
{
case CaseState.Empty:
MainGame.ViewerMovePlayer(bot.X, bot.Y, (byte)(bot.X + x), (byte)(bot.Y + y));
MainGame.TheMap[bot.X, bot.Y] = CaseState.Empty;
bot.X = (byte)(bot.X + x);
bot.Y = (byte)(bot.Y + y);
MainGame.TheMap[bot.X, bot.Y] = CaseState.Ennemy;
SendPositionToCockpit();
break;
case CaseState.Energy:
MainGame.ViewerClearCase((byte)(bot.X + x), (byte)(bot.Y + y));
MainGame.ViewerMovePlayer(bot.X, bot.Y, (byte)(bot.X + x), (byte)(bot.Y + y));
MainGame.TheMap[bot.X, bot.Y] = CaseState.Empty;
bot.X = (byte)(bot.X + x);
bot.Y = (byte)(bot.Y + y);
MainGame.TheMap[bot.X, bot.Y] = CaseState.Ennemy;
UInt16 temp = (UInt16)(MainGame.RND.Next(1 + MainGame.Settings.EnergyPodMax - MainGame.Settings.EnergyPodFrom) + MainGame.Settings.EnergyPodFrom);
bot.Energy += temp;
Console.WriteLine($"Bot {bot.Name} win energy: {temp}");
bot.Score += MainGame.Settings.PointByEnergyFound;
SendPositionToCockpit();
break;
case CaseState.Ennemy: // on tamponne un bot adverse
if (bot.ShieldLevel >= MainGame.Settings.EnergyLostContactEnemy)
{
bot.ShieldLevel -= MainGame.Settings.EnergyLostContactEnemy;
MainGame.ViewerPlayerShield(bot.X, bot.Y, bot.ShieldLevel);
}
else
{
UInt16 tmp = bot.ShieldLevel;
bot.ShieldLevel = 0;
tmp = (UInt16)(2 * (MainGame.Settings.EnergyLostContactEnemy - tmp));
if (bot.Energy >= tmp)
{
bot.Energy -= tmp;
}
else
{
bot.Energy = 0;
}
}
// perte du champ occultant
if (bot.CloakLevel > 0)
{
bot.CloakLevel = 0;
MainGame.ViewerPlayerCloak(bot.X, bot.Y, bot.CloakLevel);
}
bot.Score += MainGame.Settings.PointByEnnemyTouch;
Console.WriteLine($"Bot {bot.Name} tamponne un bot ennemi !");
TouchEnemy((UInt16)(bot.X + x), (UInt16)(bot.Y + y));
break;
case CaseState.Wall:
if (bot.ShieldLevel > 0)
{
bot.ShieldLevel--;
MainGame.ViewerPlayerShield(bot.X, bot.Y, bot.ShieldLevel);
}
else
{
if (bot.Energy > MainGame.Settings.EnergyLostContactWall)
{
bot.Energy -= MainGame.Settings.EnergyLostContactWall;
}
else
{
bot.Energy = 0;
}
}
// perte du champ occultant
if (bot.CloakLevel > 0)
{
bot.CloakLevel = 0;
MainGame.ViewerPlayerCloak(bot.X, bot.Y, bot.CloakLevel);
}
break;
}
await SendChangeInfo();
//MainGame.RefreshViewer();
if (bot.Energy == 0)
{
await SendDead();
}
} // DoMove
public void ChangeDirection(MoveDirection newDirection)
{
this.snakeDirection = newDirection;
}
public MainFieldSquareState(bool isActive, uint obstacle, Direction direction)
{
Obstacle = obstacle;
IsActive = isActive;
Direction = new MoveDirection(direction);
}
