public void CheckMove_d16A0_ToD1()
{
// MOVE <ea>,<ea>
// 0001 0010 0010 1000 0x1228
// 0000 0000 0000 0002 0x0002
// MOVE (d16,A0),D1
byte[] data = new byte[]
{
0x12, 0x28, 0x00, 0x02
};
MegadriveState state = new MegadriveState(new Data(data), 0x00000000, 0x00000000, 0x000000, 0x3FFFFF, 0x0FF0000, 0xFFFFFF);
state.WriteAReg(0x0, 0x00FF0000);
state.WriteByte(0x00FF0002, 0xAA);
state.FetchOpCode();
var opcode = new MOVE(state);
Assert.That(opcode.Assembly, Is.EqualTo("MOVE.b ($0002,A0),D1"));
Assert.That(state.PC, Is.EqualTo(0x04));
Assert.That(state.ReadAReg(0x0), Is.EqualTo(0x00FF0000));
Assert.That(state.ReadDReg(0x1), Is.EqualTo(0x000000AA));
}
public Snake()
{
snakePos = new List <Position>();
snakeLength = 1;
snakeMoveDirection = MOVE.RIGHT;
}
// 0.5초마다 객체들을 회전하면서 (글로벌 방향으로) 이동시키기
IEnumerator MixedAct() // 즉, 2개의 동작을 처리. <-- 여러 동작이 있다 가정했을때, 수정해야 한다면?
{
while (true)
{
// 회전
player1.transform.Rotate(90.0f * Vector3.up);
player2.transform.Rotate(90.0f * Vector3.up);
if (player1.transform.position.x < -4)
{
move = MOVE.MOVE_RIGHT;
}
else if (player1.transform.position.x > 4)
{
move = MOVE.MOVE_LEFT;
}
// 왼쪽으로 갔다, 오른쪽으로 갔다 하고 있다.
if (move == MOVE.MOVE_RIGHT)
{
player1.transform.Translate(1.0f * Vector3.right, Space.World);
player2.transform.Translate(-1.0f * Vector3.right, Space.World);
}
else
{
player1.transform.Translate(-1.0f * Vector3.right, Space.World);
player2.transform.Translate(1.0f * Vector3.right, Space.World);
}
yield return(new WaitForSeconds(0.5f)); // 0.5초 씩 기다리면서 계속 반복문을 돌린다.
}
}
public void update()
{
if (m_move == MOVE.IDLE)
{
destx = x;
desty = y;
}
else if (m_move == MOVE.DOWN)
{
y += 0.05f;
if (desty + 1.0f > y)
{
m_move = MOVE.DOWN;
}
else
{
m_move = MOVE.IDLE;
y = desty + 1.0f;
}
}
else if (m_move == MOVE.LEFT)
{
x -= 0.05f;
if (destx - 1.0f < x)
{
m_move = MOVE.LEFT;
}
else
{
m_move = MOVE.IDLE;
x = destx - 1.0f;
}
}
else if (m_move == MOVE.RIGHT)
{
x += 0.05f;
if (destx + 1.0f > x)
{
m_move = MOVE.RIGHT;
}
else
{
m_move = MOVE.IDLE;
x = destx + 1.0f;
}
}
else if (m_move == MOVE.UP)
{
y -= 0.05f;
if (desty - 1.0f < y)
{
m_move = MOVE.UP;
}
else
{
m_move = MOVE.IDLE;
y = desty - 1.0f;
}
}
}
public void Del(MOVE _dir)
{
string huongdi;
switch (_dir)
{
case MOVE.UP: huongdi = "UP"; break;
case MOVE.DOWN: huongdi = "DOWN"; break;
case MOVE.LEFT: huongdi = "LEFT"; break;
default: huongdi = "RIGHT"; break;
}
int i = 0;
while (i < _numDirection && _direction[i] != huongdi)
{
i++;
}
if (i == _numDirection)
{
return;
}
_numDirection--;
while (i < _numDirection)
{
_direction[i] = _direction[i + 1];
i++;
}
}
public NPuzzle UnMove()
{
NPuzzle PuzzleCopy = (NPuzzle)this.Clone();
if (PuzzleCopy.m_PreviousMoves.Count > 0)
{
MOVE Move = PuzzleCopy.m_PreviousMoves[PuzzleCopy.m_PreviousMoves.Count - 1];
PuzzleCopy.m_PreviousMoves.RemoveAt(m_PreviousMoves.Count - 1);
iVec2 Empty = PuzzleCopy.EmptyTile();
switch (Move)
{
case MOVE.UP:
PuzzleCopy.SwitchTiles(Empty, new iVec2(Empty.x, Empty.y - 1));
break;
case MOVE.RIGHT:
PuzzleCopy.SwitchTiles(Empty, new iVec2(Empty.x + 1, Empty.y));
break;
case MOVE.LEFT:
PuzzleCopy.SwitchTiles(Empty, new iVec2(Empty.x - 1, Empty.y));
break;
case MOVE.DOWN:
PuzzleCopy.SwitchTiles(Empty, new iVec2(Empty.x, Empty.y + 1));
break;
}
}
return(PuzzleCopy);
}
public void ClientTick(RealmTime time, MOVE pkt)
{
int lastClientTime = LastClientTime;
long lastServerTime = LastServerTime;
LastClientTime = pkt.Time;
LastServerTime = time.TotalElapsedMs;
if (lastClientTime == -1)
{
return;
}
_clientTimeLog.Enqueue(pkt.Time - lastClientTime);
_serverTimeLog.Enqueue((int)(time.TotalElapsedMs - lastServerTime));
if (_clientTimeLog.Count < 30)
{
return;
}
if (_clientTimeLog.Count > 30)
{
int ignore;
_clientTimeLog.TryDequeue(out ignore);
_serverTimeLog.TryDequeue(out ignore);
}
}
public void ClientTick(RealmTime time, MOVE pkt)
{
var lastClientTime = LastClientTime;
var lastServerTime = LastServerTime;
LastClientTime = pkt.Time;
LastServerTime = time.TotalElapsedMs;
if (lastClientTime == -1)
{
return;
}
_clientTimeLog.Enqueue(pkt.Time - lastClientTime);
_serverTimeLog.Enqueue((int)(time.TotalElapsedMs - lastServerTime));
if (_clientTimeLog.Count < 30)
{
return;
}
if (_clientTimeLog.Count > 30)
{
int ignore;
_clientTimeLog.TryDequeue(out ignore);
_serverTimeLog.TryDequeue(out ignore);
}
var clientDeltaAvg = _clientTimeLog.Sum() / _clientTimeLog.Count;
var serverDeltaAvg = _serverTimeLog.Sum() / _serverTimeLog.Count;
var dx = clientDeltaAvg > serverDeltaAvg
? clientDeltaAvg - serverDeltaAvg
: serverDeltaAvg - clientDeltaAvg;
}
public Position PositionAfterMove(MOVE m)
{
Position ret;
switch (m)
{
case MOVE.UP:
ret = new Position(x, y - 1);
break;
case MOVE.DOWN:
ret = new Position(x, y + 1);
break;
case MOVE.LEFT:
ret = new Position(x - 1, y);
break;
case MOVE.RIGHT:
ret = new Position(x + 1, y);
break;
case MOVE.STAY:
default:
ret = new Position(x, y);
break;
}
return(ret);
}
public void movieUtils(MOVE move, Rigidbody2D corpoRigido, float speed)
{
switch (move)
{
case MOVE.Baixo:
corpoRigido.transform.Translate(Vector3.down * (speed * Time.deltaTime));
break;
case MOVE.Cima:
corpoRigido.transform.Translate(Vector3.up * (Time.deltaTime * speed));
break;
case MOVE.Direita:
corpoRigido.transform.Translate(Vector3.right * (Time.deltaTime * speed));
break;
case MOVE.Esquerda:
corpoRigido.transform.Translate(Vector3.left * (Time.deltaTime * speed));
break;
default:
corpoRigido.transform.Translate(Vector3.zero * (Time.deltaTime * speed));
break;
}
}
public static string MoveToString(MOVE move)
{
string ret = "UP";
switch (move)
{
case MOVE.UP:
ret = "UP";
break;
case MOVE.DOWN:
ret = "DOWN";
break;
case MOVE.LEFT:
ret = "LEFT";
break;
case MOVE.RIGHT:
ret = "RIGHT";
break;
case MOVE.STAY:
ret = "STAY";
break;
}
return(ret);
}
private void trackBar1_Scroll(object sender, EventArgs e)
{
PS3.Extension.WriteFloat(Addresses[physics.SelectedIndex], speed.Value);
value.Text = "Current Value: " + speed.Value.ToString();
if (physics.Text == "Move Speed")
{
MOVE.Start();
}
else
{
MOVE.Stop();
}
if (physics.Text == "Jump Speed")
{
speed.Minimum = 04;
}
if (physics.Text == "Walk Through Walls")
{
clip.Enabled = false;
}
else
{
clip.Enabled = true;
}
speed.Maximum = 800;
}
public NPuzzle Move(MOVE Move)
{
NPuzzle PuzzleCopy = (NPuzzle)this.Clone();
PuzzleCopy.m_PreviousMoves.Add(Move);
iVec2 Empty = EmptyTile();
#if DEBUG
System.Diagnostics.Debug.WriteLineIf(!this.AvalibleMoves.Contains(Move), "UnValid Move Maid");
#endif
switch (Move)
{
case MOVE.DOWN:
PuzzleCopy.SwitchTiles(Empty, new iVec2(Empty.x, Empty.y - 1));
break;
case MOVE.LEFT:
PuzzleCopy.SwitchTiles(Empty, new iVec2(Empty.x + 1, Empty.y));
break;
case MOVE.RIGHT:
PuzzleCopy.SwitchTiles(Empty, new iVec2(Empty.x - 1, Empty.y));
break;
case MOVE.UP:
PuzzleCopy.SwitchTiles(Empty, new iVec2(Empty.x, Empty.y + 1));
break;
}
return(PuzzleCopy);
}
public void Init(Image _image)
{
m_image = _image;
preimage = MOVE.IDLE;
x = 0.0f;
y = 0.0f;
m_move = MOVE.IDLE;
}
public Move(MOVE direction, float lifeTime, float timeTolerance, Transform player)
{
_lifeTime = lifeTime;
_spawnedTime = Time.time;
_direction = direction;
_time = _spawnedTime + _lifeTime/2;
_timeTolerance = timeTolerance;
_player = player;
}
public EnemyAction(MOVE action, float waiting)
{
if(action < MOVE.WAIT)
{
waiting = 0f;
}else{
timeWait = waiting;
}
state = action;
}
public void SetRock(o_Rock o_rock, MOVE right_left, int rockCol, int rockRow)
{
o_rock.Move(this, right_left, rockCol, rockRow, CalcMoveToPosition((int)right_left, rockCol, rockRow));
if (right_left == MOVE.RIGHT)
{
list_rocksR[rockCol][rockRow] = o_rock;
return;
}
list_rocksL[rockCol][rockRow] = o_rock;
}
void Update()
{
Debug.Log("Working");
if (isPaused)
{
return;
}
if (battleController.isWinnerExist)
{
return;
}
if (hamerHitCoroutine != null)
{
return;
}
if (battleController.playingPlayers[battleController.curPlayer].isComputer == false)
{
if (Input.anyKeyDown)
{
hamerHitCoroutine = StartCoroutine(hamerHitIEnumerator());
}
}
else
{
if (computerMove == MOVE.NONE)
{
if (battleController.nail.transform.localPosition.y - maxHitPower * (1 - StaticVars.computerHitRange) <= BattleController.NAIL_MIN)
{
computerMove = MOVE.HIT_HARD;
}
else
{
computerMove = MOVE.HIT_SOFT;
}
}
else
{
switch (computerMove)
{
case MOVE.HIT_HARD:
hamerHitCoroutine = StartCoroutine(hamerHitIEnumerator(Random.Range(1 - StaticVars.computerHitRange, 1)));
computerMove = MOVE.NONE;
break;
case MOVE.HIT_SOFT:
float neededStranght = ((battleController.nail.transform.localPosition.y - BattleController.NAIL_MIN) / maxHitPower) % 1;
hamerHitCoroutine = StartCoroutine(hamerHitIEnumerator(Random.Range(neededStranght, neededStranght + StaticVars.computerHitRange)));
computerMove = MOVE.NONE;
break;
}
}
}
}
public void Advance(MOVE status, Vector2 direction)
{
if (status == MOVE.PUSH)
{
push(direction);
}
else if (status == MOVE.WALK)
{
walk(direction);
}
}
public Snake()
{
snakePos = new Position[Const.SNAKE_SIZE];
for (int i = 0; i < Const.SNAKE_SIZE; i++)
{
snakePos[i] = new Position();
}
snakeLength = 1;
snakeMoveDirection = MOVE.RIGHT;
}
public EnemyAction(MOVE action, float waiting)
{
if (action < MOVE.WAIT)
{
waiting = 0f;
}
else
{
timeWait = waiting;
}
state = action;
}
/* Changes position of the player
* Changes position.x or position.y relative to the direction of gravity
*/
private void Movement(MOVE tempMove)
{
if (!rotLevel)
{
if (currGrav.Equals(GRAVITY.UP) || currGrav.Equals(GRAVITY.DOWN))
{
if (tempMove.Equals(MOVE.LEFT))
{
currentPos.x += -0.05f;
currentMovement = MOVE.LEFT;
transform.position = currentPos;
}
else if (tempMove.Equals(MOVE.RIGHT))
{
currentPos.x += 0.05f;
currentMovement = MOVE.RIGHT;
transform.position = currentPos;
}
}
else if (currGrav.Equals(GRAVITY.LEFT) || currGrav.Equals(GRAVITY.RIGHT))
{
if (tempMove.Equals(MOVE.LEFT))
{
currentPos.y += -0.05f;
currentMovement = MOVE.LEFT;
transform.position = currentPos;
}
else if (tempMove.Equals(MOVE.RIGHT))
{
currentPos.y += 0.05f;
currentMovement = MOVE.RIGHT;
transform.position = currentPos;
}
}
}
else
{
if (tempMove.Equals(MOVE.LEFT))
{
currentPos.x += -0.05f;
currentMovement = MOVE.LEFT;
transform.position = currentPos;
}
else if (tempMove.Equals(MOVE.RIGHT))
{
currentPos.x += 0.05f;
currentMovement = MOVE.RIGHT;
transform.position = currentPos;
}
}
}
private void MoveCharacter(ref PictureBox target, int xData, int yData, int zData, ref MOVE state)
{
MOVE pre_state = state;
// update orientation
if (xData > ORIENTATION_UP)
{
target.Top -= 2;
state = MOVE.UP;
}
else if (xData < ORIENTATION_LOW)
{
target.Top += 2;
state = MOVE.DOWN;
}
else if (yData > ORIENTATION_UP)
{
target.Left -= 2;
state = MOVE.LEFT;
}
else if (yData < ORIENTATION_LOW)
{
target.Left += 2;
state = MOVE.RIGHT;
}
else
{
if (state == MOVE.DOWN)
{
state = MOVE.DOWN_STAT;
}
else if (state == MOVE.LEFT)
{
state = MOVE.LEFT_STAT;
}
else if (state == MOVE.RIGHT)
{
state = MOVE.RIGHT_STAT;
}
else if (state == MOVE.UP)
{
state = MOVE.UP_STAT;
}
}
if (pre_state != state)
{
UpdateCharacter(ref target, ref state);
}
}
public Snake(Position startPos)
{
snakePos = new List <Position>();
if (startPos.X % 2 != 0)
{
startPos.X += 1;
}
snakePos.Add(new Position(startPos.X, startPos.Y));
snakePos.Add(new Position(startPos.X - 2, startPos.Y));
snakeLength = 1;
snakeMoveDirection = MOVE.RIGHT;
}
public void ProcessEntryExit(Level level, Exp body, bool returnValue)
{
Stm stm = null;
if (returnValue)
{
stm = new MOVE(new TEMP(level.Frame.RV()), body.UnEx());
}
else
{
stm = body.UnNx();
}
stm = level.Frame.ProcessEntryExit1(stm);
AddFrag(new ProcFrag(stm, level.Frame));
}
public Snake()
{
snakePos = new List <Position>();
//int y = Const.Y_SIZE / 2;
//int x = Const.X_SIZE / 2;
//if (x % 2 != 0)
// x += 1;
//snakePos.Add(new Position(x, y));
//snakePos.Add(new Position(x - 2, y));
snakeLength = 1;
snakeMoveDirection = MOVE.RIGHT;
}
public Character(string n, Point p)
{
name = n;
if (name == "bomberman")
{
down = new BitmapImage(new Uri(graphics + "Bomberman/down.gif"));
down_static = new BitmapImage(new Uri(graphics + "Bomberman/Front/Bman_F_f00.png"));
up = new BitmapImage(new Uri(graphics + "Bomberman/up.gif"));
up_static = new BitmapImage(new Uri(graphics + "Bomberman/Back/Bman_B_f00.png"));
left = new BitmapImage(new Uri(graphics + "Bomberman/left.gif"));
left_static = new BitmapImage(new Uri(graphics + "Bomberman/Left/Bman_F_f00.png"));
right = new BitmapImage(new Uri(graphics + "Bomberman/right.gif"));
right_static = new BitmapImage(new Uri(graphics + "Bomberman/Right/Bman_F_f00.png"));
offset = 64;
}
else if (name == "creep")
{
down = new BitmapImage(new Uri(graphics + "Creep/down.gif"));
down_static = new BitmapImage(new Uri(graphics + "Creep/Front/Creep_F_f00.png"));
up = new BitmapImage(new Uri(graphics + "Creep/up.gif"));
up_static = new BitmapImage(new Uri(graphics + "Creep/Back/Creep_B_f00.png"));
left = new BitmapImage(new Uri(graphics + "Creep/left.gif"));
left_static = new BitmapImage(new Uri(graphics + "Creep/Left/Creep_S_f00.png"));
right = new BitmapImage(new Uri(graphics + "Creep/right.gif"));
right_static = new BitmapImage(new Uri(graphics + "Creep/Right/Creep_S_f00.png"));
offset = 0;
}
direction = MOVE.DOWN_STAT;
img = new Image
{
Width = down.Width,
Height = down.Height,
};
Canvas.SetTop(img, -offset + p.X);
Canvas.SetLeft(img, p.Y);
ImageBehavior.SetAnimatedSource(img, down_static);
result = new Image
{
Width = 64 * 6,
Height = 64 * 6,
Stretch = Stretch.Fill,
Visibility = Visibility.Hidden
};
}
void Update()
{
if (!isDead) // 살아있으면
{
if (move == MOVE.STOP) // 이동 타입이 STOP인 경우 (최초 생성시 이 루틴을 타게 된다.)
{
if (Random.Range(0, 100) == 0) // 1%의 확률로
{
move = Random.Range(0, 2) == 0 ? MOVE.LEFT : MOVE.RIGHT; // 0~1 사이의 난수를 발생시켜 좌우 중에 하나로 설정한다.
}
}
else if (move == MOVE.LEFT)
{
transform.localScale = new Vector3(1f, 1f, 1f); // 스케일을 원래대로 보이게 한다.
transform.Translate(Vector3.left * Speed * Time.deltaTime); // 좌측으로 이동시킨다.
// layerMask를 1 << 9로 지정한 것은 땅 타일의 레이어 값이 9이므로 땅만 체크하기 위한 것이다.
// 캐릭터의 아래로 0.1f 거리까지 레이저를 쏴서 땅이 있는지 체크한다. 이 값이 false이면 공중에 떠 있는 것이므로 반대쪽으로 이동하게 한다.
// 캐릭터의 좌측으로 0.5f 거리까지 레이저를 쏴서 땅이 있는지 체크한다. 이 값이 true이면 캐릭터 앞에 벽이 있는 것이므로 반대쪽으로 이동하게 한다.
if (!Physics2D.Raycast(transform.position, Vector3.down, 0.1f, 1 << 9) || Physics2D.Raycast(transform.position, Vector3.left, 0.5f, 1 << 9))
{
move = MOVE.RIGHT;
}
else if (Random.Range(0, 100) == 0) // 혹은 1%의 확률로 STOP 상태를 만든다. (잠깐 멈춰서 생각하게 하는듯한 연출)
{
move = MOVE.STOP;
}
}
else if (move == MOVE.RIGHT)
{
transform.localScale = new Vector3(-1f, 1f, 1f); // X축 스케일을 -1f로 지정해 스프라이트를 좌우 반전시킨다.
transform.Translate(Vector3.right * Speed * Time.deltaTime); // 우측으로 이동시킨다.
// layerMask를 1 << 9로 지정한 것은 땅 타일의 레이어 값이 9이므로 땅만 체크하기 위한 것이다.
// 캐릭터의 아래로 0.1f 거리까지 레이저를 쏴서 땅이 있는지 체크한다. 이 값이 false이면 공중에 떠 있는 것이므로 반대쪽으로 이동하게 한다.
// 캐릭터의 우측으로 0.5f 거리까지 레이저를 쏴서 땅이 있는지 체크한다. 이 값이 true이면 캐릭터 앞에 벽이 있는 것이므로 반대쪽으로 이동하게 한다.
if (!Physics2D.Raycast(transform.position, Vector3.down, 0.1f, 1 << 9) || Physics2D.Raycast(transform.position, Vector3.right, 0.5f, 1 << 9))
{
move = MOVE.LEFT;
}
else if (Random.Range(0, 100) == 0) // 혹은 1%의 확률로 STOP 상태를 만든다. (잠깐 멈춰서 생각하게 하는듯한 연출)
{
move = MOVE.STOP;
}
}
}
}
private void TranslateStm(MOVE stm)
{
if (stm.Dst is TEMP)
{
if (stm.Src is CONST)
{
InstrList.Add(new MoveInt((stm.Dst as TEMP).Temp, (stm.Src as CONST).Value));
}
else if (stm.Src is MEM)
{
Temp.Temp mem;
int offset;
if ((stm.Src as MEM).Exp is BINOP && ((stm.Src as MEM).Exp as BINOP).Right is CONST)
{
mem = TranslateExpr(((stm.Src as MEM).Exp as BINOP).Left);
offset = (((stm.Src as MEM).Exp as BINOP).Right as CONST).Value;
}
else
{
mem = TranslateExpr((stm.Src as MEM).Exp);
offset = 0;
}
InstrList.Add(new Load(mem, offset, TranslateExpr(stm.Dst)));
}
else
{
InstrList.Add(new Move((stm.Dst as TEMP).Temp, TranslateExpr(stm.Src)));
}
}
else if (stm.Dst is MEM)
{
Temp.Temp mem;
int offset;
if ((stm.Dst as MEM).Exp is BINOP && ((stm.Dst as MEM).Exp as BINOP).Right is CONST)
{
mem = TranslateExpr(((stm.Dst as MEM).Exp as BINOP).Left);
offset = (((stm.Dst as MEM).Exp as BINOP).Right as CONST).Value;
}
else
{
mem = TranslateExpr((stm.Dst as MEM).Exp);
offset = 0;
}
InstrList.Add(new Store(mem, offset, TranslateExpr(stm.Src)));
}
}
// Update is called once per frame
void Update()
{
if (_mainGame.IsGameEnd == true)
{
return;
}
// PUSHED
if (!_IsMoving && Time.timeSinceLevelLoad <= _moveEndTime)
{
// Attacker gets pushed
Vector3 pushedDist = _moveDir * pushMult;
Vector3 targetPos = transform.position + pushedDist;
float step = Time.deltaTime * 7.0f;
transform.position = Vector3.MoveTowards(transform.position, targetPos, step);
return;
}
else
{
// Attacker finished pushed away
_IsMoving = true;
}
// MOVING
if (_IsMoving && !_IsCapturing)
{
// Move towards her
bool IsOnRightSide = (_her.transform.position.x <= transform.position.x);
if (IsOnRightSide)
{
side = MOVE.LEFT;
_moveDir = Vector3.left;
_spriteRenderer.flipX = true;
}
else
{
side = MOVE.RIGHT;
_moveDir = Vector3.right;
_spriteRenderer.flipX = false;
}
transform.Translate(_moveDir * _walkSpeed * Time.deltaTime);
}
}
private void TranslateStm(MOVE stm)
{
if (stm.Dst is TEMP)
{
if (stm.Src is CONST)
InstrList.Add(new MoveInt((stm.Dst as TEMP).Temp, (stm.Src as CONST).Value));
else if (stm.Src is MEM)
{
Temp.Temp mem;
int offset;
if ((stm.Src as MEM).Exp is BINOP && ((stm.Src as MEM).Exp as BINOP).Right is CONST)
{
mem = TranslateExpr(((stm.Src as MEM).Exp as BINOP).Left);
offset = (((stm.Src as MEM).Exp as BINOP).Right as CONST).Value;
}
else
{
mem = TranslateExpr((stm.Src as MEM).Exp);
offset = 0;
}
InstrList.Add(new Load(mem, offset, TranslateExpr(stm.Dst)));
}
else
{
InstrList.Add(new Move((stm.Dst as TEMP).Temp, TranslateExpr(stm.Src)));
}
}
else if (stm.Dst is MEM)
{
Temp.Temp mem;
int offset;
if ((stm.Dst as MEM).Exp is BINOP && ((stm.Dst as MEM).Exp as BINOP).Right is CONST)
{
mem = TranslateExpr(((stm.Dst as MEM).Exp as BINOP).Left);
offset = (((stm.Dst as MEM).Exp as BINOP).Right as CONST).Value;
}
else
{
mem = TranslateExpr((stm.Dst as MEM).Exp);
offset = 0;
}
InstrList.Add(new Store(mem, offset, TranslateExpr(stm.Src)));
}
}
public MOVE ActionKeyBoard()
{
if ((Input.GetKey(KeyCode.UpArrow) || angle > 70 && angle < 110) && _moveDefalt != MOVE.Baixo)
{
_moveDefalt = MOVE.Cima;
}
if ((Input.GetKey(KeyCode.DownArrow) || angle > 250 && angle < 290) && _moveDefalt != MOVE.Cima)
{
_moveDefalt = MOVE.Baixo;
}
if ((Input.GetKey(KeyCode.LeftArrow) || angle < 200 && angle > 160) && _moveDefalt != MOVE.Direita)
{
_moveDefalt = MOVE.Esquerda;
}
if ((Input.GetKey(KeyCode.RightArrow) || (angle < 20 && angle < 0) || angle > 340) && _moveDefalt != MOVE.Esquerda)
{
_moveDefalt = MOVE.Direita;
}
return(_moveDefalt);
}
public void SetDirection(MOVE inSide)
{
if (_mainGame.IsGameEnd == true)
{
return;
}
if (inSide == MOVE.RIGHT) // when user input is RIGHT
{
_playerMoveDir = Vector3.right;
_spriteRenderer.flipX = true;
side = MOVE.RIGHT;
}
else // when user input is LEFT
{
_playerMoveDir = Vector3.left;
_spriteRenderer.flipX = false;
side = MOVE.LEFT;
}
}
private void Move(int x, int y)
{
if (!_canMove)
{
return;
}
Vector2 direction = new Vector2(x, y);
MOVE result = _motor.move(direction);
if (result == MOVE.FAIL)
{
return;
}
_animator.Advance(result, direction);
GameManager.Instance.State.Move();
StartCoroutine(MoveTimer());
}
public void addAction(MOVE action, float waiting)
{
moveList.Add(new EnemyAction(action, waiting < 0.2f ? 0.2f : waiting));
}
public void placeUIWay(MOVE action, bool helico)
{
var theTurn = actualEnemyEdit.isMakingATurn();
if(action == MOVE.LEFT){
addGameObjectToList(lineObject, -90f, actualEnemyEdit.getLastPosition(), helico);
}else if(action == MOVE.RIGHT){
addGameObjectToList(lineObject, 90f, actualEnemyEdit.getLastPosition(), helico);
}else if(action == MOVE.UP){
addGameObjectToList(lineObject, 0f, actualEnemyEdit.getLastPosition(), helico);
}else if(action == MOVE.DOWN){
addGameObjectToList(lineObject, 180f, actualEnemyEdit.getLastPosition(), helico);
}
if(theTurn != TURN.NONE)
{
replaceTurnObject(theTurn);
}
}
public void ProcessEntryExit(Level level, Exp body, bool returnValue)
{
Stm stm = null;
if (returnValue)
stm = new MOVE(new TEMP(level.Frame.RV()), body.UnEx());
else
stm = body.UnNx();
stm = level.Frame.ProcessEntryExit1(stm);
AddFrag(new ProcFrag(stm, level.Frame));
}
public void init(int entityCode_, int childCode_)
{
moveScript = gameObject.GetComponent<MOVE>();
attackScript = gameObject.GetComponent<ATTACK>();
skillManager = gameObject.GetComponent<SkillManager> ();
buffManager = gameObject.GetComponent<Buffmanager>();
entityCode = entityCode_;
entityName = Config.name[entityCode];
gameObject.name = entityName;
fullHp = Config.fullHp[entityCode];
currHp = fullHp;
bonusDamage = 0;
str = Config.str[entityCode];
dex = Config.dex[entityCode];
accuracyRate = dex * Config.accuracyRatePerDex;
avoidRate = dex * Config.avoidRatePerDex;
criticalRate = luck * Config.criticalRatePerLuck;
absoluteAvoidRate = luck * Config.absoluteAvoidRatePerLuck;
trapFindRate = intelligence * Config.trapFindRatePerIntelligence;
cocktailSuccessRate = 0.5f + intelligence * Config.cocktailSuccessRatePerIntelligence;
labeledAlcoholDropRate = 0.05f + luck * Config.labeledAlcoholDropRatePerLuck;
rareItemDropRate = 0.1f + luck * Config.rareItemDropRatePerLuck;
luckZeroDeathRate = Config.luckZeroDeathRate;
if (dex <= 0){
speedLevel = 1;
countPerTurn = 8;
}else if (dex > 0 && dex <= 30){
speedLevel = 2;
countPerTurn = 4;
}else if (dex > 30 && dex <= 60){
speedLevel = 3;
countPerTurn = 2;
}else if (dex >60){
speedLevel = 4;
countPerTurn = 1;
}
//Debug.Log (name + " : counterPerTurn == " + countPerTurn);
intelligence = Config.intelligence[entityCode];
luck = Config.luck[entityCode];
fullMp = Config.fullMp;
currMp = 0;
bloodSuck = 0;
isKoala = false;
isStun = false;
isOoC = false;
drunkenType = Config.drunkenType[entityCode];
turnCount = 0;
range = Config.range[entityCode];
sight = Config.sight[entityCode];
regenHp = 0.2f;
regenMp = -2;
regenHpBuffer = 0;
skillStandBy = -1;
isSustain = false;
alcoholStack = 0;
transform.FindChild ("Image").GetComponent<SpriteRenderer> ().sortingOrder = ((int)transform.position.y);
initChild (childCode_);
}
private void OnMoveBeingGenerated(MOVE m)
{
currentIndex = (currentIndex + 1)%moves.Length;
moves[currentIndex] = new Move(tableMut[Random.Range(0, tableMut.Length)], lifeTime, timeTolerance, transform);
if (NewMoveGenerated != null) NewMoveGenerated(moves[currentIndex]);
}
public bool Check(MOVE direction)
{
if (_used)
{
return false;
}
if (_direction == direction)
{
_used = true;
Spawner.Instance.ThrowKwiatekAround(_player.position,3);
if (Used != null) Used(true);
AudienceSatisfaction.Instance.Good();
}
return _direction == direction;
}
void PrintStm(MOVE s, int d)
{
Indent(d); SayLn("MOVE("); PrintExp(s.Dst, d + 1); SayLn(",");
PrintExp(s.Src, d + 1); Say(")");
}
public string convertMoveToString(MOVE m)
{
switch(m)
{
case MOVE.WAIT:
return "Wait";
case MOVE.LOOKUP:
return "Look Up";
case MOVE.LOOKRIGHT:
return "Look Right";
case MOVE.LOOKLEFT:
return "Look Left";
case MOVE.LOOKDOWN:
return "Look Down";
}
return "error";
}
