public override CharacterState UpdataState(Character character, InputOrder input)
{
CharacterState tempState = this;
if (character.OnGround())
{
//Debug.Log("On Ground Now.");
switch (input)
{
case InputOrder.stand:
tempState = new IdleState();
break;
case InputOrder.walk:
tempState = new WalkState();
break;
case InputOrder.squat:
tempState = new SquatState();
break;
default:
tempState = new IdleState();
break;
}
}
return(tempState);
}
private void MakeFSM()
{
IdleState idle = new IdleState();
idle.AddTransition(Transition.Walk, StateID.Walk);
idle.AddTransition(Transition.Jump, StateID.Jump);
idle.AddTransition(Transition.Die, StateID.Die);
WalkState walk = new WalkState(path);
walk.AddTransition(Transition.Idle, StateID.Idle);
walk.AddTransition(Transition.Jump, StateID.Jump);
walk.AddTransition(Transition.Die, StateID.Die);
JumpState jump = new JumpState();
jump.AddTransition(Transition.Idle, StateID.Idle);
jump.AddTransition(Transition.Die, StateID.Die);
DeadState die = new DeadState();
fsm = new FSMSystem();
fsm.AddState(idle);
fsm.AddState(walk);
fsm.AddState(jump);
fsm.AddState(die);
}
// Update is called once per frame
void FixedUpdate()
{
//print (state);
//print (finalizingMovement);
float force = Input.GetAxisRaw ("Vertical");
//float force = 0;
float twist = Input.GetAxisRaw ("Horizontal");
if (twist == 1) {
hips.SendMessage("turnRight");
}
else if (twist == -1) {
hips.SendMessage("turnLeft");
}
if (force == 0) {
if(state == WalkState.STAND){
state = WalkState.STAND;
}
else{
finalizingMovement = true; // telling that it should give the last step
}
}
else if(state == WalkState.STAND)
state = WalkState.CROUCH_TO_WALK;
}
public void SetStealth()
{
walkState = WalkState.STEALTH;
stateText.text = "M:" + walkState.ToString();
//temp code
animator.SetBool("isWalking", false);
}
public void SetWalk(float speedMod)
{
stepPeriod = 0.45f / speedMod;
if (walkState == WalkState.NONE)
{
walkTimer = stepPeriod;
}
animator.SetBool("isWalking", true);
animator.SetFloat("walkSpeed", speedMod);
if (speedMod == 1)
{
walkState = WalkState.NORMAL;
stateText.text = "M:" + walkState.ToString();
}
else if (speedMod < 1)
{
walkState = WalkState.SLOW;
stateText.text = "M:" + walkState.ToString();
}
else if (speedMod > 1)
{
walkState = WalkState.FAST;
stateText.text = "M:" + walkState.ToString();
}
}
// Use this for initialization
void Start () {
hips = GameObject.Find("/swat/Hips");
state = WalkState.STAND;
isFirstStep = true;
finalizingMovement = false;
}
// Update is called once per frame
void FixedUpdate () {
//print (state);
//print (finalizingMovement);
float force = Input.GetAxisRaw ("Vertical");
//float force = 0;
float twist = Input.GetAxisRaw ("Horizontal");
if (twist == 1) {
hips.SendMessage("turnRight");
}
else if (twist == -1) {
hips.SendMessage("turnLeft");
}
if (force == 0) {
if(state == WalkState.STAND){
state = WalkState.STAND;
}
else{
finalizingMovement = true; // telling that it should give the last step
}
}
else if(state == WalkState.STAND)
state = WalkState.CROUCH_TO_WALK;
}
public static bool CalcTypeList(this List<Variable> ps, WalkState ws)
{
Type type = null;
for (int i = ps.Count - 1; i >= 0; i--)
{
if (ps[i].Type == null)
{
ps[i].SystemType = type;
}
else
{
type = ps[i].Type.ToType(ws);
ps[i].SystemType = type;
}
}
bool retVal = true;
foreach (var p in ps)
{
if (p.SystemType == null)
{
ws.AddError("Type could not be determined for " + p.Name);
retVal = false;
}
}
return retVal;
}
private bool CheckForStepPerFoot(Vector3[] data)
{
if (Vector3.Angle(data[2], data[3]) > thresholdAngleInDegreeInStep)
{
return(false);
}
float kneeHipLength = (data[0] - data[1]).magnitude;
if (avgKneeHipLength < 0.01f)
{
avgKneeHipLength = kneeHipLength;
}
if (Mathf.Abs((kneeHipLength / avgKneeHipLength) - 1.0f) < 0.05f)
{
avgKneeHipLength = (avgKneeHipLength + kneeHipLength) * 0.5f;
}
float heightDifference = Mathf.Abs(data[0].y - data[1].y);
if ((heightDifference / avgKneeHipLength) >= thresholdKneeHipLengthInPercentageInStep)
{
return(false);
}
currentWalkState = WalkState.InStep;
return(true);
}
public static FSMStateMachine GetCharacterEditorFSM(Creature owner)
{
FSMTranslationMap translationMap = new FSMTranslationMap();
DeadState dead = new DeadState(owner);
AttackState attackState = new AttackState(owner);
IdleState idle = new IdleState(owner);
WalkState walk = new WalkState(owner);
HitState hitState = new HitState(owner);
RunState runState = new RunState(owner);
HitMoveState hitMoveState = new HitMoveState(owner);
HitFlyState hitFlyState = new HitFlyState(owner);
translationMap.addState(dead);
translationMap.addState(idle);
translationMap.addState(walk);
translationMap.addState(runState);
translationMap.addState(hitState);
translationMap.addState(hitMoveState);
translationMap.addState(attackState);
translationMap.addState(hitFlyState);
translationMap.MixAll();
translationMap.check();
FSMStateMachine fsm = new FSMStateMachine(translationMap);
return(fsm);
}
public PlayerState(IEventManager playerEvent)
{
#region Player State Initialization
_StateIdle = new IdleState(this);
_StateWalk = new WalkState(this);
_StateSprint = new SprintState(this);
_StateFall = new FallState(this);
_StateCrouch = new CrouchState(this);
_StateJump = new JumpState(this);
_StateCrouchWalk = new CrouchWalkState(this);
_StateSlide = new SlideState(this);
_StateCrouchJump = new CrouchJumpState(this);
_StateCrouchFall = new CrouchFallState(this);
_StateAirMoveCrouchFall = new AirMoveCrouchFallState(this);
_StateAirMoveCrouchJump = new AirMoveCrouchJumpState(this);
_StateAirMoveFall = new AirMoveFallState(this);
_StateAirMoveJump = new AirMoveJumpState(this);
#endregion
_ActiveProxies = new HashSet <IDynamicProxy>();
_EventPlayer = playerEvent;
_CurrentPlayerState = _StateIdle;
#region State Proxy Initialization
_MediatorToggleProxy = new ToggleProxyMediator();
_ProxySprint = new SprintProxy(this, _MediatorToggleProxy);
_ProxyCrouch = new CrouchProxy(this, _MediatorToggleProxy);
_MediatorToggleProxy.ProxyCrouch = _ProxyCrouch;
_MediatorToggleProxy.ProxySprint = _ProxySprint;
_ProxyWalk = new WalkProxy(this, _MediatorToggleProxy);
_ProxyFall = new FallProxy(this);
_ProxyJump = new JumpProxy(this, _MediatorToggleProxy);
#endregion
}
public override CharacterState UpdataState(Character character, InputOrder input)
{
CharacterState tempState = this;
if (!character.OnGround())
{
tempState = new JumpState();
}
else
{
switch (input)
{
case InputOrder.stand:
tempState = new IdleState();
break;
case InputOrder.jump:
character.DoJump();
tempState = new JumpState();
break;
case InputOrder.walk:
tempState = new WalkState();
break;
}
}
return(tempState);
}
public void ChangeValue(int value)
{
switch (value)
{
case 1:
state = WalkState.F;
break;
case 2:
state = WalkState.B;
break;
case 3:
state = WalkState.L;
break;
case 4:
state = WalkState.R;
break;
default:
break;
}
RandomWalk(state);
}
public void OnPressed()
{
if (myIsReleased == true /*&& (myWalkState == WalkState.Stay || myWalkState == WalkState.Down)*/)
{
myActuallSpeed = mySpeed;
myWalkState = WalkState.Up;
}
}
public override void Update()
{
_waiter.Update();
if (_waiter.Done())
{
var walk = new WalkState(_cat, rand.Next(0, 2));
_cat.Switch(walk);
}
}
private void OnEnable()
{
myIsReleased = false;
myActuallSpeed = 0f;
//myIsPressed = false;
mySpeed = (float)Camera.main.pixelHeight / mySpeedPercent;
myDeacceleration = Camera.main.pixelHeight / 100f * myDeacceleratingPerccent;
myWalkState = WalkState.Stay;
}
void OnTriggerEnter2D(Collider2D col)
{
if (col.gameObject.CompareTag("Player"))
{
//May not be necessary. Might be better to assign on Start.
player = col.gameObject;
enemyState = WalkState.PURSUE;
}
}
// Start is called before the first frame update
void Start()
{
rb = GetComponent <Rigidbody2D>();
enemyState = WalkState.PATROL;
visionObject = transform.GetChild(0);
changeDirection();
movementTimer = TIMER;
restTimer = TIMER;
Random.InitState(System.DateTime.Now.Millisecond);
}
public void Reset()
{
_currentMarker = null;
_nextMarkNo = 0;
_total_accum_len = 0;
_expectedSegmentLen = 0;
_state = WalkState.Init;
_nextMarkNo = 0;
_latest_X = _latest_Y =
_latest_moveto_Y = _latest_moveto_Y = 0;
}
public void GenClassItems(WalkState ws, ITypeContainer parent)
{
var c = parent.GetClass(ws.Assembly, ws.Namespace, Name, Public);
foreach (var s in Statements)
{
var t = s.GetType();
if (t == typeof(Class))
{
(s as Class).GenClassItems(ws, c);
}
else if (t == typeof(FunctionDef))
{
c.Functions.Add(new Function(c, s as FunctionDef, ws));
}
else if (t == typeof(PropertySet))
{
var ps = s as PropertySet;
if (ps.CalcTypeList(ws))
{
ExprList el = null;
if (ps.Vals != null)
{
el = ps.Vals as ExprList;
if (ps.Props.Count != el.Expressions.Count)
{
ws.AddError("Mismatched property/value counts: " + ps.Props.Count + " != " + el.Expressions.Count);
el = null;
}
}
for (int i = 0; i < ps.Props.Count; i++)
{
var p = ps.Props[i];
var prop = p.Static ? new Constant(p, ws) : new Field(p, ws);
prop.CreateField(c);
if (el != null)
{
object val = el.Expressions[i].Calculate(ws);
if (val != null)
{
prop.SetDefault(p.SystemType.Cast(val, ws));
}
// TODO - Do something with default values for fields.
}
c.Fields.Add(prop);
}
}
}
else
{
ws.AddError("Unknown class statement: " + t);
}
}
}
// Use this for initialization
void Start()
{
manager = (GameObject.Find("Manager") as GameObject).GetComponent <Manager>();
manager.NewBlorp(this);
age = 0;
time = 0;
loving = false;
actualState = new WalkState(this);
}
private void Awake()
{
agent = GetComponent <aAgent>();
idleState = new IdleState(this);
walkState = new WalkState(this);
aggroState = new AggroState(this);
currentState = idleState;
destination = FindObjectOfType <Castle> ().transform;
}
/// <summary> Сброс параметров противника </summary>
public void Reset(Vector2 position, Vector2 point)
{
_isActive = true;
_enemyObject.transform.localScale = new Vector3(Scale, Scale, 1);
Transform.position = position;
Vector2 direction = (point - position).normalized;
State = new WalkState(direction, this);
_enemyObject.SetActive(true);
}
private void initializeSateMachine()
{
idleState = new IdleState();
walkState = new WalkState();
attackState = new AttackState();
fallState = new FallState();
playerStateMachine = new StateMachine <Player>(this, idleState);
playerStateMachine.addState(walkState);
playerStateMachine.addState(attackState);
playerStateMachine.addState(fallState);
}
public override void update()
{
if (mWalkState == null)
{
if (mCenterPosition == null)
{
mCenterPosition = parent.mMapPosition;
}
mWalkState = new StoppingState(this);
}
mWalkState.update();
}
void Awake()
{
isFlip = false;
charcter_state[0] = new IdelState(gameObject); //默认状态
charcter_state[1] = new WalkState(gameObject); //行走状态
charcter_state[2] = new AttackState(gameObject); //攻击状态
charcter_state[3] = new DefendState(gameObject); //防御状态
CurrentState = new State(gameObject);
CurrentState = charcter_state[0];
DataInit();
UiInit();
}
void Awake()
{
var walkState = new WalkState(this);
var runState = new RunState(this);
mFsm.AddState(walkState);
mFsm.AddState(runState);
mFsm.AddTransition(new SpaceKeyDown());
mFsm.AddTransition(new SpaceKeyUp());
mFsm.StartState <WalkState>();
}
private void OnTriggerEnter2D(Collider2D collision)
{
if (collision.gameObject.layer == LayerMask.NameToLayer("Goal"))
{
GameManager.Instance.AddScore(1);
myActuallSpeed *= 5;
Destroy(gameObject, 1f);
//StartCoroutine(WinDelay());
}
else if (collision.gameObject.layer == LayerMask.NameToLayer("KillZone"))
{
myWalkState = WalkState.Stay;
}
}
public void Reset()
{
_currentMark = null;
_nextMarkNo = 0;
_expectedSegmentLen = 0;
_state = WalkState.Init;
_nextMarkNo = 0;
_latest_X = _latest_Y =
_latest_moveto_Y = _latest_moveto_Y = 0;
_total_accum_len = 0;
_tempPoints.Clear();
_output = null;
}
// Use this for initialization
void Start()
{
idleState = new IdleState();
walkState = new WalkState();
jumpState = new JumpState();
currentState = State_Player.IDLE;
oldState = State_Player.NONE;
//add
stateMachine.Add(State_Player.IDLE, idleState.PlayerEnter, idleState.PlayerUpdate, idleState.PlayerExit);
stateMachine.Add(State_Player.WALK, walkState.PlayerEnter, walkState.PlayerUpdate, walkState.PlayerExit);
stateMachine.Add(State_Player.JUMP, jumpState.PlayerEnter, jumpState.PlayerUpdate, jumpState.PlayerExit);
}
// Start is called before the first frame update
void Start()
{
_currentWalkState = WalkState.OffPath;
if (myPathCreator)
{
_maxDistanceTraveled = myPathCreator.path.length;
}
else
{
_maxDistanceTraveled = 0;
}
_anim = GetComponent <Animator>();
_sprite = GetComponent <SpriteRenderer>();
}
private void Awake()
{
chaseState = new ChaseState(this);
patrolState = new PatrolState(this);
guardState = new GuardState(this);
dazedState = new DazedState(this);
distractedState = new DistractedState(this);
searchingState = new SearchingState(this);
suspiciousState = new SuspiciousState(this);
koState = new KOState(this);
walkState = new WalkState(this);
navMeshAgent = GetComponent <NavMeshAgent>();
}
private void MakeFSM()
{
IdleState idleState = new IdleState(this, StateID.IdleState);
WalkState walkState = new WalkState(this, StateID.PatrolState, walkSpeed);
//IdleState
idleState.AddTransition(new TimeTransition(walkState, idleTime));
//WalkState
walkState.AddTransition(new TimeTransition(idleState, walkTime));
_fsm.AddState(idleState);
_fsm.AddState(walkState);
}
public void GenClassItems(WalkState ws)
{
ws.FileReset();
foreach (var s in Statements)
{
var t = s.GetType();
if (t == typeof(Class))
{
(s as Class).GenClassItems(ws, ws.Assembly);
}
else if (t == typeof(Namespace))
{
var n = s as Namespace;
ws.Namespace = n.Name.ToString();
}
}
}
public List<Type> CalcTypes(WalkState ws)
{
List<Type> ltl = Left.CalcTypes(ws);
List<Type> rtl = Right.CalcTypes(ws);
if (ltl.Count == rtl.Count && ltl.Count == 1)
{
Type lt = ltl[0];
Type rt = rtl[0];
if (Op.IsBooleanOp()) { return new List<Type> { typeof(bool) }; }
else if (Op == TokenType.As) { return rtl; }
else if (lt == typeof(string) || rt == typeof(string)) { return new List<Type> { typeof(string) }; }
else if (lt == rt) { return ltl; }
}
ws.AddError("Cannot apply binary operator " + Op + " with " + ltl.Count + " type(s) and " + rtl.Count + " type(s).");
return new List<Type> { };
}
public void GenTypes(WalkState ws, ITypeContainer parent)
{
if (!string.IsNullOrEmpty(ws.Namespace))
{
var c = parent.GetClass(ws.Assembly, ws.Namespace, Name, Public);
foreach(var s in Statements)
{
var t = s.GetType();
if (t == typeof(Class))
{
(s as Class).GenTypes(ws, c);
}
}
}
else
{
ws.AddError("No namespace specified for class " + Name);
}
}
public static object Cast(this Type type, object val, WalkState ws)
{
if (type == typeof(bool)) { return Convert.ToBoolean(val); }
else if (type == typeof(char)) { return Convert.ToChar(val); }
else if (type == typeof(float)) { return Convert.ToSingle(val); }
else if (type == typeof(double)) { return Convert.ToDouble(val); }
else if (type == typeof(sbyte)) { return Convert.ToSByte(val); }
else if (type == typeof(short)) { return Convert.ToInt16(val); }
else if (type == typeof(int)) { return Convert.ToInt32(val); }
else if (type == typeof(long)) { return Convert.ToInt64(val); }
else if (type == typeof(byte)) { return Convert.ToByte(val); }
else if (type == typeof(ushort)) { return Convert.ToUInt16(val); }
else if (type == typeof(uint)) { return Convert.ToUInt32(val); }
else if (type == typeof(ulong)) { return Convert.ToUInt64(val); }
else if (type == typeof(string)) { return Convert.ToString(val); }
ws.AddError("Cannot convert '" + val + "' to " + type);
return null;
}
public static bool CalcTypeList(this PropertySet ps, WalkState ws)
{
Type type = null;
for (int i = ps.Props.Count - 1; i >= 0; i--)
{
if (ps.Props[i].Type == null)
{
ps.Props[i].SystemType = type;
}
else
{
type = ps.Props[i].Type.ToType(ws);
ps.Props[i].SystemType = type;
}
}
if (ps.Vals != null)
{
var types = (ps.Vals as ExprList).CalcTypes(ws);
if (ps.Props.Count == types.Count)
{
for (int i = 0; i < ps.Props.Count; i++)
{
if (ps.Props[i].SystemType == null)
{
ps.Props[i].SystemType = types[i];
}
}
}
}
bool retVal = true;
foreach (var p in ps.Props)
{
if (p.SystemType == null)
{
ws.AddError("Type could not be determined for " + p.Name);
retVal = false;
}
}
return retVal;
}
void standPosition()
{
finalizingMovement = false;
isFirstStep = true;
state = WalkState.STAND;
}
void rightStep()
{
state = WalkState.RIGHT_STEP;
//print (state);
}
void rightStepCalculate()
{
state = WalkState.CALCULATE_RIGHT_STEP;
//print (state);
}
void liftingToStand()
{
state = WalkState.RISE_TO_STAND;
}
void pickLeg()
{
state = WalkState.PICK_LEG;
}
public List<Type> CalcTypes(WalkState ws)
{
return new List<Type> { };
}
void leftStepCalculate()
{
state = WalkState.CALCULATE_LEFT_STEP;
//print (state);
}
void crouchToWalk()
{
state = WalkState.CROUCH_TO_WALK;
//print (state);
}
public List<Type> CalcTypes(WalkState ws)
{
return new List<Type> { this.ToType(ws) };
}
public object Calculate(WalkState ws)
{
return null;
}
public object Calculate(WalkState ws)
{
var ts = Expr.CalcTypes(ws);
if (ts.Count != 1)
{
ws.AddError("Cannot use a unary operator on a type with " + ts.Count + " return type(s).");
return null;
}
Type type = ts[0];
var val = Expr.Calculate(ws);
switch (Op)
{
case TokenType.Sub:
if (type.IsFloatingPointType())
{
return type.Cast(-Convert.ToDouble(val), ws);
}
else if (type.IsIntegerType())
{
return type.Cast(-Convert.ToInt64(val), ws);
}
ws.AddError("Cannot negate a field of type " + type);
return null;
case TokenType.Not:
if (type == typeof(bool)) { return !(bool)val; }
ws.AddError("Cannot use not on a field of type " + type);
return null;
}
ws.AddError("Unknown unary op encountered when calculating value: " + Op);
return null;
}
public List<Type> CalcTypes(WalkState ws)
{
var types = new List<Type>();
foreach (var e in Expressions) { types.AddRange(e.CalcTypes(ws)); }
return types;
}
public object Calculate(WalkState ws)
{
return Val[0];
}
public List<Type> CalcTypes(WalkState ws)
{
return new List<Type> { typeof(char) };
}
public object Calculate(WalkState ws)
{
return Convert.ToDouble(Val);
}
void leftStep()
{
state = WalkState.LEFT_STEP;
//print (state);
}
public List<Type> CalcTypes(WalkState ws)
{
return Expr.CalcTypes(ws);
}
/// <summary>
/// Initialize controlling state machine
/// </summary>
private void InitializeStateMachine()
{
//states
IdleState idleState = new IdleState();
idleState.Parent = this;
mStateMachine.AddState(idleState);
WalkState walkState = new WalkState();
walkState.Parent = this;
mStateMachine.AddState(walkState);
/*
RunState runState = new RunState();
runState.Parent = this;
mStateMachine.AddState(runState);
*/
GetWalkTarget getWalkTargetState = new GetWalkTarget();
getWalkTargetState.Parent = this;
mStateMachine.AddState(getWalkTargetState);
SpawnInState spawnInState = new SpawnInState();
spawnInState.Parent = this;
mStateMachine.AddState(spawnInState);
SpawnOutState spawnOutState = new SpawnOutState();
spawnOutState.Parent = this;
mStateMachine.AddState(spawnOutState);
DeadState deadState = new DeadState();
deadState.Parent = this;
mStateMachine.AddState(deadState);
EatCarrotState eatCarrotState = new EatCarrotState();
eatCarrotState.Parent = this;
mStateMachine.AddState(eatCarrotState);
EatFlowerState eatFlowerState = new EatFlowerState();
eatFlowerState.Parent = this;
mStateMachine.AddState(eatFlowerState);
WinDanceState winDanceState = new WinDanceState();
winDanceState.Parent = this;
mStateMachine.AddState(winDanceState);
LostState lostState = new LostState();
lostState.Parent = this;
mStateMachine.AddState(lostState);
//transitions
mStateMachine.AddTransition((int)CharacterEvents.To_Walk, idleState, walkState);
mStateMachine.AddTransition((int)CharacterEvents.To_GetTarget, idleState, getWalkTargetState);
mStateMachine.AddTransition((int)CharacterEvents.To_Idle, walkState, idleState);
mStateMachine.AddTransition((int)CharacterEvents.To_GetTarget, walkState, getWalkTargetState);
mStateMachine.AddTransition((int)CharacterEvents.To_Walk, getWalkTargetState, walkState);
mStateMachine.AddTransition((int)CharacterEvents.To_Idle, getWalkTargetState, idleState);
mStateMachine.AddTransition((int)CharacterEvents.To_GetTarget, spawnInState, getWalkTargetState);
mStateMachine.AddTransition((int)CharacterEvents.To_SpawnOut, getWalkTargetState, spawnOutState);
mStateMachine.AddTransition((int)CharacterEvents.To_EatCarrot, getWalkTargetState, eatCarrotState);
mStateMachine.AddTransition((int)CharacterEvents.To_EatFlower, getWalkTargetState, eatFlowerState);
mStateMachine.AddTransition((int)CharacterEvents.To_Dead, spawnOutState, deadState);
mStateMachine.AddTransition((int)CharacterEvents.To_GetTarget, eatCarrotState, getWalkTargetState);
mStateMachine.AddTransition((int)CharacterEvents.To_GetTarget, eatFlowerState, getWalkTargetState);
mStateMachine.AddTransition((int)CharacterEvents.To_WinDance, getWalkTargetState, winDanceState);
mStateMachine.AddTransition((int)CharacterEvents.To_WinDance, idleState, winDanceState);
mStateMachine.AddTransition((int)CharacterEvents.To_WinDance, walkState, winDanceState);
mStateMachine.AddTransition((int)CharacterEvents.To_WinDance, spawnInState, winDanceState);
mStateMachine.AddTransition((int)CharacterEvents.To_WinDance, spawnOutState, winDanceState);
mStateMachine.AddTransition((int)CharacterEvents.To_WinDance, eatFlowerState, winDanceState);
mStateMachine.AddTransition((int)CharacterEvents.To_WinDance, eatCarrotState, winDanceState);
mStateMachine.AddTransition((int)CharacterEvents.To_Lost, idleState, lostState);
mStateMachine.AddTransition((int)CharacterEvents.To_Lost, walkState, lostState);
mStateMachine.AddTransition((int)CharacterEvents.To_Lost, getWalkTargetState, lostState);
mStateMachine.AddTransition((int)CharacterEvents.To_Lost, spawnInState, lostState);
mStateMachine.AddTransition((int)CharacterEvents.To_Lost, spawnOutState, lostState);
mStateMachine.AddTransition((int)CharacterEvents.To_Lost, eatFlowerState, lostState);
mStateMachine.AddTransition((int)CharacterEvents.To_Lost, eatCarrotState, lostState);
#if (WINDOWS_PHONE && !SILVERLIGHT)
mStateMachine.AddTransition((int)CharacterEvents.To_SpawnIn, deadState, spawnInState);
#endif
//mStateMachine.AddTransition((int)CharacterEvents.To_Run, walkState, runState);
//mStateMachine.AddTransition((int)CharacterEvents.TimerElapsed, runState, walkState);
// character starts in a spawn in state
#if (WINDOWS_PHONE && !SILVERLIGHT)
mStateMachine.StartState = deadState;
#else
mStateMachine.StartState = spawnInState;
#endif
}
public List<Type> CalcTypes(WalkState ws)
{
return new List<Type> { typeof(string) };
}
// Use this for initialization
void Start()
{
hips = GameObject.Find("/swat/Hips");
state = WalkState.STAND;
isFirstStep = true;
finalizingMovement = false;
}
public object Calculate(WalkState ws)
{
Type lt, rt;
object left = Left.Calculate(ws);
object right = Right.Calculate(ws);
switch (Op)
{
case TokenType.As:
rt = Right.CalcTypes(ws)[0];
return rt.Cast(left, ws);
case TokenType.Is:
var lts = Left.CalcTypes(ws);
rt = Right.CalcTypes(ws)[0];
return (lts.Count == 1 && lts[0] == rt);
case TokenType.Add:
lt = CalcTypes(ws)[0];
if (lt.IsFloatingPointType())
{
return lt.Cast(Convert.ToDouble(left) + Convert.ToDouble(right), ws);
}
else if (lt.IsIntegerType())
{
return lt.Cast(Convert.ToInt64(left) + Convert.ToInt64(right), ws);
}
else if (lt == typeof(string))
{
return left.ToString() + right.ToString();
}
break;
case TokenType.Sub:
lt = CalcTypes(ws)[0];
if (lt.IsFloatingPointType())
{
return lt.Cast(Convert.ToDouble(left) - Convert.ToDouble(right), ws);
}
else if (lt.IsIntegerType())
{
return lt.Cast(Convert.ToInt64(left) - Convert.ToInt64(right), ws);
}
break;
case TokenType.Mul:
lt = CalcTypes(ws)[0];
if (lt.IsFloatingPointType())
{
return lt.Cast(Convert.ToDouble(left) * Convert.ToDouble(right), ws);
}
else if (lt.IsIntegerType())
{
return lt.Cast(Convert.ToInt64(left) * Convert.ToInt64(right), ws);
}
break;
case TokenType.Div:
lt = CalcTypes(ws)[0];
if (lt.IsFloatingPointType())
{
return lt.Cast(Convert.ToDouble(left) / Convert.ToDouble(right), ws);
}
else if (lt.IsIntegerType())
{
return lt.Cast(Convert.ToInt64(left) / Convert.ToInt64(right), ws);
}
break;
case TokenType.Mod:
lt = CalcTypes(ws)[0];
if (lt.IsIntegerType())
{
return lt.Cast(Convert.ToInt64(left) % Convert.ToInt64(right), ws);
}
break;
case TokenType.BAnd:
case TokenType.BOr:
case TokenType.BXOr:
break;
case TokenType.Equal:
return (left as IComparable).CompareTo(right) == 0;
case TokenType.NotEqual:
return (left as IComparable).CompareTo(right) != 0;
case TokenType.LeftCaret:
return (left as IComparable).CompareTo(right) < 0;
case TokenType.LtEqual:
return (left as IComparable).CompareTo(right) < 1;
case TokenType.RightCaret:
return (left as IComparable).CompareTo(right) > 0;
case TokenType.GtEqual:
return (left as IComparable).CompareTo(right) > -1;
case TokenType.And:
return ((bool)left) && ((bool)right);
case TokenType.Or:
return ((bool)left) || ((bool)right);
}
ws.AddError("Could not calculate binary operator: " + Op);
return null;
}
public object Calculate(WalkState ws)
{
return Convert.ToInt64(Val);
}
