//stops us from sending multiple rpc calls to display the gui if it is already being displayed
public ArenaState(StateManager manager)
{
this.manager = manager;
manager.StartCoroutine ("BreakDelay");
timeUntilNextWave = Time.time + timeBetweenWaves;
waveNumber = 0;
}
public BeginState (StateMangaer managerRef)//contructor
{
manager = managerRef;
futureTime = screenDuration + Time.realtimeSinceStartup;
Time.timeScale = 0;
Debug.Log("Constructing BeginState");
}
private void InitialzeStateManager()
{
_stateManager = new StateManager(_muffinAnimator);
IdleState idle = new IdleState(_stateManager, transform);
MoveState move = new MoveState(_stateManager, transform);
TrapState trap = new TrapState(_stateManager, transform);
DieState die = new DieState(_stateManager, transform);
SpinState spin = new SpinState(_stateManager, transform);
BlastState blast = new BlastState(_stateManager, transform);
ChocoRushState chocoRush = new ChocoRushState(_stateManager, transform);
PauseState pause = new PauseState(_stateManager, transform);
_stateManager.AddCharacterState(idle);
_stateManager.AddCharacterState(move);
_stateManager.AddCharacterState(trap);
_stateManager.AddCharacterState(die);
_stateManager.AddCharacterState(spin);
_stateManager.AddCharacterState(blast);
_stateManager.AddCharacterState(chocoRush);
_stateManager.AddCharacterState(pause);
_stateManager.SetDefaultState("Pause");
}
public void ExecuteContinousInvalidCommand()
{
var stateManager = new StateManager();
var game = new TestGameImplementation();
game.Initialize<DefaultPlayer>(null);
var commands = CommandFactory.GetCommands(new Assembly[] { Assembly.GetExecutingAssembly() });
if (commands.Count() == 0)
{
Assert.Fail("No commands were fetched from the factory.");
}
stateManager.Initialize(game.Player, commands);
stateManager.PerformCommand(new ReceivedInputMessage("CommandWithInput"));
Assert.IsTrue(game.Messages.Count > 0);
Assert.IsNotNull(game.Player.StateManager.CurrentState);
Assert.IsTrue(game.Player.StateManager.CurrentState.GetType() == typeof(ReceivingInputState));
stateManager.PerformCommand(new ReceivedInputMessage("someRandomStuff"));
Assert.IsTrue(game.Messages.Count > 0);
Assert.IsNotNull(game.Player.StateManager.CurrentState);
Assert.IsTrue(game.Player.StateManager.CurrentState.GetType() == typeof(TestState));
stateManager.PerformCommand(new ReceivedInputMessage("randomMessage"));
Assert.IsTrue(game.Messages.Pop() == "Invalid command used!" + Environment.NewLine);
}
//private PlayerScript controller;
public PlayState2 (StateManager managerRef)
{ //Constructor
manager = managerRef;
Debug.Log ("Constructing PlayState2");
manager.darkState = false;
"Stage2".LoadScene ();
//if (Application.loadedLevelName != "Stage2")
// Application.LoadLevel ("Stage2");
StaticMethods.SetOneActive ("Following Camera", manager.gameDataRef.cameras); //Camera that follows the Player, setOneActive method
player = GameObject.FindGameObjectWithTag ("Player"); //the Player GameObject is now active and can be found
player.GetComponent<Rigidbody2D> ().isKinematic = false; //Player is now affected by physics
player.transform.SetPositionXY (-6.0f, -0.4f); //set starting position for Player
skin = Resources.Load ("GUISkin") as GUISkin;
//darkness = GameObject.FindGameObjectWithTag ("Darkness");
//dark.a += 0f;
//darkness.GetComponent<Renderer>().material.color = dark;
//darkness.GetComponent<Renderer>().material.color.a;
//Color dark = darkness.renderer.material.color;
//dark.a -= 0;
//darkness.renderer.material.color = color;
}
public PlayStateScene2(StateManager managerRef)
{
manager = managerRef;
if(Application.loadedLevelName != "Scene2")
Application.LoadLevel("Scene2");
player = GameObject.Find("Player");
controller = player.GetComponent < PlayerControl > ();
player.rigidbody.isKinematic = false;
foreach(var camera in manager.gameDataRef.cameras)
{
if(camera.name != "Following Camera")
{
if (camera != null)
camera.SetActive(false);
}
else
{
if (camera != null)
camera.SetActive(true);
}
}
}
//Constructor for BeginState
public BeginState(StateManager managerRef)
{
manager = managerRef;
if(Application.loadedLevelName != "Scene0Menu"){
Application.LoadLevel("Scene0Menu");
}
}
// Constructor
public BeginState(StateManager manageRef)
{
manager = manageRef;
futureTime = screenDuration + Time.realtimeSinceStartup;
Debug.Log("Constructing BeginState");
Time.timeScale = 1;
}
public void ShouldStartAndStopListening()
{
var fixtureSnapshot = new Fixture { Id = "TestId", MatchStatus = "30", Sequence = 1 };
var plugin = new Mock<IAdapterPlugin>();
var resource = new Mock<IResourceFacade>();
var connector = new Mock<IAdapterPlugin>();
var eventState = new Mock<IEventState>();
var marketFilterObjectStore = new StateManager(_settings.Object,plugin.Object);
resource.Setup(r => r.Sport).Returns("Football");
resource.Setup(r => r.Content).Returns(new Summary());
resource.Setup(r => r.StartStreaming()).Raises(r => r.StreamConnected += null, EventArgs.Empty);
resource.Setup(r => r.StopStreaming()).Raises(r => r.StreamDisconnected += null, EventArgs.Empty);
resource.Setup(r => r.GetSnapshot()).Returns(FixtureJsonHelper.ToJson(fixtureSnapshot));
resource.Setup(r => r.Id).Returns("TestId");
eventState.Setup(e => e.GetCurrentSequence(It.IsAny<string>(), It.IsAny<string>())).Returns(-1);
var listener = new StreamListener(resource.Object, connector.Object, eventState.Object, marketFilterObjectStore,_settings.Object);
listener.MonitorEvents();
listener.Start();
listener.Stop();
listener.ShouldRaise("OnConnected");
listener.ShouldNotRaise("OnError");
listener.ShouldRaise("OnStop");
listener.ShouldNotRaise("OnDisconnected","The disconnection is triggered by the user");
connector.Verify(c => c.ProcessSnapshot(It.IsAny<Fixture>(), false), Times.Once());
}
public static void resetReferencesForNewLevel()
{
// Managers
manager = GameObject.FindGameObjectWithTag("Manager");
stateManager = manager.GetComponent<StateManager>();
stateTiming = manager.GetComponent<StateTiming>();
// Game stats and information
gameStats = manager.GetComponent<GameStats>();
itemDatabase = manager.GetComponent<Item_Database>();
inventory = manager.GetComponent<Inventory>();
market = manager.GetComponent<Market>();
marketArrays = manager.GetComponent<MarketArrays>();
soundEffects = GameObject.FindObjectOfType<SoundEffectsDatabase>().GetComponent<SoundEffectsDatabase>();
// Cameras
realtimeCamera = GameObject.FindGameObjectWithTag("Camera_Realtime").GetComponent<Camera>();
strategicCamera = GameObject.FindGameObjectWithTag("Camera_Strategic").GetComponent<Camera>();
// Game entities
player = GameObject.FindGameObjectWithTag("Player");
castle = GameObject.FindGameObjectWithTag("Castle");
soundEffect = (GameObject)Resources.Load("OneTimeSoundEffect", typeof(GameObject));
// Data
lastLevelIndex = Application.loadedLevel;
currentLevel = 1;
}
public SpaceDefenderPlayingState(StateManager gameStateManager)
{
_gameStateManager = gameStateManager;
IDrawableGameComponent backdrop = new Backdrop(new Vector2(GameRoot.ScreenSize.X / 2.0f, GameRoot.ScreenSize.Y / 2.0f));
_gameComponents.Add("backdrop", backdrop);
var projectiles = new ProjectileList(Vector2.Zero);
_gameComponents.Add("projectiles", projectiles);
IDrawableGameComponent player = new Player(new Vector2(GameRoot.ScreenSize.X / 2.0f, GameRoot.ScreenSize.Y - 50.0f), projectiles);
_gameComponents.Add("player", player);
IDrawableGameComponent alien1 = new Alien(new Vector2(GameRoot.ScreenSize.X / 2.0f, GameRoot.ScreenSize.Y / 2.0f));
_gameComponents.Add("alien1", alien1);
IDrawableGameComponent alien2 = new Alien2(new Vector2(100.0f, 100.0f));
_gameComponents.Add("alien2", alien2);
//IDrawableGameComponent explosion = new AnimatedSprite("toets", Vector2.Zero, 1, 16, 1, 50);
IDrawableGameComponent explosion = new Explosion(Vector2.Zero);
explosion.IsAlive = false;
_gameComponents.Add("explosion", explosion);
IDrawableGameComponent hud = new Hud { Score = 0, Lives = 3 };
_gameComponents.Add("hud", hud);
_random = new Random();
}
public KinectHelpState(string name, StateManager manager, string mainWindow, string whereWindow, bool avatar)
: base(name, manager)
{
mInput = manager.Coordinator.GetPlugin<KinectMovementPlugin>();
mMainWindow = manager.Coordinator[mainWindow];
mWhereWindow = whereWindow;
mWhereButton = new ImageHoverTrigger(mMainWindow.OverlayManager, new DialCursorRenderer(), new OverlayImage(new Bitmap(mWhereAmIImage), .65f, .25f, mainWindow));
mWhereButton.Triggered += new Action(mWhereButton_Triggered);
mCloseWhereButton = new ImageHoverTrigger(Manager.Coordinator[whereWindow].OverlayManager, new DialCursorRenderer(), mWhereButton.Image);
mCloseWhereButton.Triggered += new Action(mCloseWhereButton_Triggered);
mClickTrigger = new CursorTrigger(new CircleRenderer(100), mMainWindow);
SkeletonFeature helpSkeleton = new SkeletonFeature(.065f, 0f, avatar ? .23f : .13f, 125f, mainWindow);
AddFeature(helpSkeleton);
AddFeature(new OverlayImage(new Bitmap(avatar ? mHelpAvatarImages : mHelpFlycamImages), .05f, avatar ? .2f : .1f, mainWindow));
AddFeature(mClickTrigger);
//AddFeature(mWhereButton);
mWhereButton.Active = false;
mCloseWhereButton.Active = false;
}
public WonStateScene2(StateManager managerRef)
{
manager = managerRef;
if(Application.loadedLevelName != "Scene0"){
Application.LoadLevel("Scene0");
}
}
public PlayState1 (StateManager managerRef)
{ //Constructor
manager = managerRef;
Debug.Log ("Constructing PlayState1 from Xamarin");
"Stage1".LoadScene ();
//if (Application.loadedLevelName != "Stage1")
// Application.LoadLevel ("Stage1");
//StaticMethods.SetActive ("Player", manager.gameDataRef.activeObjects); //Set Player active, setOneActive method
StaticMethods.SetActive ("Darkness_Layer", manager.gameDataRef.activeObjects);
StaticMethods.SetOneActive ("Following Camera", manager.gameDataRef.cameras); //Camera that follows the Player, setOneActive method
//"Following Camera".SetOneActive (manager.gameDataRef.cameras);
//setManyActive (managerRef.gameDataRef.GUIObjects); //Set all GUI elements active, setActive method
player = GameObject.FindGameObjectWithTag ("Player"); //the Player GameObject is now active and can be found
player.GetComponent<Rigidbody2D> ().isKinematic = false; //Player is now affected by physics
player.transform.SetPositionXY (-5.8f, -0.4f); //set starting position for Player
player.transform.SetLocalScale (0.3f, 0.3f, 1f); //Set initial scale
skin = Resources.Load ("GUISkin") as GUISkin;
/* if (GameObject.Find ("Platform")) {
Debug.Log ("platform");
//platform = GameObject.Find ("Platform");
} else
Debug.Log ("no platform");
*/
//darkness.GetComponent<Renderer>().material.color.a;
//Color dark = darkness.renderer.material.color;
//dark.a -= 0;
//darkness.renderer.material.color = color;
}
public BeginState(StateManager managerRef)
{
manager = managerRef;
Debug.Log ("In BeginState");
if(Application.loadedLevelName != "Scene0")
Application.LoadLevel("Scene0");
}
public SetupState(StateManager managerRef)
{
manager = managerRef;
if(Application.loadedLevelName != "Scene0")
Application.LoadLevel("Scene0");
//player = GameObject.Find("Player");
//controller = player.GetComponent <PlayerControl>();
mainCamera = GameObject.Find("Main Camera");
//mainCamera = GameObject.Find("OVRPlayerController");
// Import data
newCube = GameObject.Find("Cube");
// Grab a camera
foreach(GameObject camera in manager.gameDataRef.cameras)
{
//if(camera.name != "OVRPlayerController")
if(camera.name != "Main Camera")
{
if (camera != null)
camera.SetActive(false);
}
else
{
if (camera != null)
camera.SetActive(true);
}
}
import(fileDirectory);
}
public static void SetUpMocks()
{
_settings = new Mock<ISettings>();
_settings.Setup(x => x.MarketFiltersDirectory).Returns(".");
_settings.Setup(x => x.EventStateFilePath).Returns(".");
_settings.Setup(x => x.ProcessingLockTimeOutInSecs).Returns(10);
_plugin = new Mock<IAdapterPlugin>();
_resource = new Mock<IResourceFacade>();
_resource.Setup(r => r.Sport).Returns("FantasyFootball");
_resource.Setup(r => r.StartStreaming()).Raises(r => r.StreamConnected += null, new EventArgs());
_objectProvider = new Mock <IObjectProvider<Dictionary<string, FixtureOverview>>>();
var stateManager = new StateManager(new Mock<ISettings>().Object,_plugin.Object);
_supervisor = new Supervisor(_settings.Object,_objectProvider.Object);
_supervisor.StateManager = stateManager;
var supervisorService = new Mock<ISupervisorService>();
supervisorService.Setup(x => x.StreamingService).Returns(new Mock<ISupervisorStreamingService>().Object);
_supervisor.Service = supervisorService.Object;
_supervisor.Proxy = new Mock<ISupervisorProxy>().Object;
new SuspensionManager(stateManager, _plugin.Object);
}
public Adapter(ISettings settings, IServiceFacade udapiServiceFacade, IAdapterPlugin platformConnector, IStreamListenerManager listenersManager)
{
_listenersManager = listenersManager;
Settings = settings;
UDAPIService = udapiServiceFacade;
PlatformConnector = platformConnector;
var statemanager = new StateManager(settings,platformConnector);
StateManager = statemanager;
StateProviderProxy.Init(statemanager);
listenersManager.StateManager = statemanager;
if (settings.StatsEnabled)
StatsManager.Configure();
// we just need the initialisation
new SuspensionManager(statemanager, PlatformConnector);
platformConnector.Initialise();
statemanager.AddRules(platformConnector.MarketRules);
ThreadPool.SetMinThreads(500, 500);
_sports = new List<string>();
_stats = StatsManager.Instance["adapter.core"].GetHandle();
PopuplateAdapterVersionInfo();
}
public SetupState(StateManager managerRef)
{
manager = managerRef;
gData = GameObject.Find("GameManager").GetComponent<GalaxyData>();
gameData = GameObject.Find("GameManager").GetComponent<GlobalGameData>();
Debug.Log("In SetupState");
}
public void ShouldSetCurrentToStartStateWhenCreated()
{
var state = new StartState();
var manager = new StateManager<IGameLogicState>(state);
Assert.AreSame(state, manager.Current);
}
public void ShouldBeCreatedWithNoStates()
{
var manager = new StateManager<IGameLogicState>(null);
Assert.AreEqual(0, manager.StateCount);
Assert.IsNull(manager.Current);
}
// Use this for initialization
void Start () {
controlScript = GameObject.FindGameObjectWithTag(StateManager.CONTROL_SCRIPT_TAG);
loadAssetBundle = controlScript.GetComponent<LoadAssetBundle>();
saveProgress = controlScript.GetComponent<SaveProgress>();
loadProgress = controlScript.GetComponent<LoadProgress>();
stateManager = controlScript.GetComponent<StateManager>();
}
//constructor
public NewGameState(StateManager managerRef)
{
manager = managerRef;
valuesLoaded = false; // reset
valuesEntered = false;
gameDataRef = GameObject.Find("GameManager").GetComponent<GlobalGameData>();
Debug.Log("Constructing New Game Screen");
}
void Awake (){
if (instanceRef == null) {
instanceRef = this;
DontDestroyOnLoad(gameObject);
} else{
Destroy(gameObject);
}
}
public WonStateScene1(StateManager managerRef)
{
manager = managerRef;
if(Application.loadedLevelName != "Scene 0")
Application.LoadLevel ("Scene 0");
manager.gameDataRef.SetScore ();
}
public ChaseState(StateManager manager, Transform playerUnit)
{
this.manager = manager;
tank = manager.getTransform();
playerTransform = playerUnit;
turret = tank.transform.GetChild(1).GetChild(0).GetChild(0).transform;
bulletSpawnPoint = turret.GetChild(0).GetChild(0).transform;
}
public SplashScreenState(StateManager stateManager, double secondsToWait, string nextState)
{
_stateManager = stateManager;
_delay = secondsToWait;
_nextState = nextState;
ResetSecondsToWait();
}
public void Init(StateManager manager)
{
this.manager = manager;
if (activeState != null) {
isInitStateInUpdate = true;
}
OnInit();
}
//inputs variable managerRef of type StateManager into the constructor
//We initialize a constructor
//Special method that does not have return type
//Serves same purpose as Start()/Update(): to initialize member variables
public BeginState(StateManager managerRef)
{
//Testing if the right state is being called by StateManager
Debug.Log ("Constructing BeginState");
manager = managerRef;
Time.timeScale = 0;
}
public void ShouldFailWhenTryingToAddTheSameStateTwice()
{
var state = new StartState();
var manager = new StateManager<IGameLogicState>(null);
manager.AddState(state);
manager.AddState(state);
}
public YK88State(CarSignalTranslator st, StateManager sm)
: base(st, sm)
{
this._name = "YK88";
}
//---------------------------------------------------------------------------------------------
public virtual void InventoryCardClick(StateManager stateManager, CardManager cardManager, CardInventoryButton inventoryCard)
{
return;
}
private void Awake()
{
instance = this;
}
//FUNCTION 'ADDEXITFUNCTION()'
// - ADDS A FUNCTION OF SAME TYPE AND ARGUMENT LIST TO DELEGATE 'ONEXIT'
public void AddExitFunction(Delegate del)
{
//TYPECAST DELEGATE 'DEL' WITH DELEGATE TYPE 'STATEMANAGER'
// - ADD TYPECAST DELEGATE 'DEL' TO MEMEBER DELEGATE ONEXIT
this.onExit += del as StateManager;
}
Task IBoard.Initialise(string name)
{
return(StateManager.SetStateAsync("Name", name));
}
// Start is called before the first frame update
void Start()
{
stateManager = Toolbox.GetInstance().GetStateManager();
}
private async Task <IReliableDictionary2 <string, long> > GetGatewayPingStatusDictionaryAsync()
{
return(await StateManager.GetOrAddAsync
<IReliableDictionary2 <string, long> >(GATEWAY_PING_DIC)
.ConfigureAwait(false));
}
public async Task FlowWithOutputConditionsShouldChangeStateAndSendMessage()
{
// Arrange
var input = new PlainText()
{
Text = "Ping!"
};
var messageType = "text/plain";
var pongMessageContent = "Pong!";
var poloMessageContent = "Polo!";
var flow = new Flow()
{
Id = Guid.NewGuid().ToString(),
States = new[]
{
new State
{
Id = "root",
Root = true,
Input = new Input(),
Outputs = new[]
{
new Output
{
Conditions = new []
{
new Condition
{
Values = new[] { "Marco!" }
}
},
StateId = "marco"
},
new Output
{
Conditions = new []
{
new Condition
{
Values = new[] { "Ping!" }
}
},
StateId = "ping"
}
}
},
new State
{
Id = "ping",
InputActions = new[]
{
new Action
{
Type = "SendMessage",
Settings = new JObject()
{
{ "type", messageType },
{ "content", pongMessageContent }
}
}
}
},
new State
{
Id = "marco",
InputActions = new[]
{
new Action
{
Type = "SendMessage",
Settings = new JObject()
{
{ "type", messageType },
{ "content", poloMessageContent }
}
}
}
}
}
};
var target = GetTarget();
// Act
await target.ProcessInputAsync(input, User, flow, CancellationToken);
// Assert
await StateManager.Received(1).SetStateIdAsync(flow.Id, User, "ping", Arg.Any <CancellationToken>());
await StateManager.DidNotReceive().SetStateIdAsync(flow.Id, User, "marco", Arg.Any <CancellationToken>());
await StateManager.Received(1).DeleteStateIdAsync(flow.Id, User, Arg.Any <CancellationToken>());
await Sender
.Received(1)
.SendMessageAsync(
Arg.Is <Message>(m =>
m.Id != null &&
m.To.ToIdentity().Equals(User) &&
m.Type.ToString().Equals(messageType) &&
m.Content.ToString() == pongMessageContent),
Arg.Any <CancellationToken>());
}
public async Task FlowWithMatchTextContextOutputConditionsShouldChangeStateAndSendMessage()
{
// Tests for Matches OutputConditions
// Arrange
var validInput = "Ping!";
var messageType = "text/plain";
var messageContent = "Pong!";
var input = new PlainText()
{
Text = validInput
};
var variableName = "MyVariable";
var flow = new Flow()
{
Id = Guid.NewGuid().ToString(),
States = new[]
{
new State
{
Id = "root",
Root = true,
Input = new Input
{
Variable = variableName
},
Outputs = new Output[]
{
new Output
{
Conditions = new Condition[]
{
new Condition
{
Source = ValueSource.Context,
Comparison = ConditionComparison.Matches,
Variable = variableName,
Values = new[] { "(Ping!)" }
}
},
StateId = "state2"
}
}
},
new State
{
Id = "state2",
InputActions = new Action[]
{
new Action
{
Type = "SendMessage",
Settings = new JObject()
{
{ "type", messageType },
{ "content", messageContent }
}
}
}
}
}
};
var target = GetTarget();
Context.GetVariableAsync(variableName, Arg.Any <CancellationToken>()).Returns(validInput);
// Act
await target.ProcessInputAsync(input, User, flow, CancellationToken);
// Assert
ContextProvider.Received(1).CreateContext(User, Arg.Is <LazyInput>(i => i.Content == input), flow);
await StateManager.Received(1).SetStateIdAsync(Arg.Any <string>(), Arg.Any <Identity>(), Arg.Any <string>(), Arg.Any <CancellationToken>());
await Context.Received(1).SetVariableAsync(variableName, input.Text, Arg.Any <CancellationToken>());
await Sender
.Received(1)
.SendMessageAsync(
Arg.Is <Message>(m =>
m.Id != null &&
m.To.ToIdentity().Equals(User) &&
m.Type.ToString().Equals(messageType) &&
m.Content.ToString() == messageContent),
Arg.Any <CancellationToken>());
}
public void Init(StateManager st)
{
states = st;
}
/// <summary>
/// Enabled/disabled Extended Tracking mode.
/// </summary>
/// <param name="ON"></param>
public virtual void SwitchExtendedTracking(bool extTrackingEnabled)
{
StateManager stateManager = TrackerManager.Instance.GetStateManager();
// We iterate over all TrackableBehaviours to start or stop extended tracking for the targets they represent.
bool success = true;
foreach (var tb in stateManager.GetTrackableBehaviours())
{
if (tb is ImageTargetBehaviour)
{
ImageTargetBehaviour itb = tb as ImageTargetBehaviour;
if (extTrackingEnabled)
{
if (!itb.ImageTarget.StartExtendedTracking())
{
success = false;
Debug.LogError("Failed to start Extended Tracking on Target " + itb.TrackableName);
}
}
else
{
itb.ImageTarget.StopExtendedTracking();
}
}
else if (tb is MultiTargetBehaviour)
{
MultiTargetBehaviour mtb = tb as MultiTargetBehaviour;
if (extTrackingEnabled)
{
if (!mtb.MultiTarget.StartExtendedTracking())
{
success = false;
Debug.LogError("Failed to start Extended Tracking on Target " + mtb.TrackableName);
}
}
else
{
mtb.MultiTarget.StopExtendedTracking();
}
}
else if (tb is CylinderTargetBehaviour)
{
CylinderTargetBehaviour ctb = tb as CylinderTargetBehaviour;
if (extTrackingEnabled)
{
if (!ctb.CylinderTarget.StartExtendedTracking())
{
success = false;
Debug.LogError("Failed to start Extended Tracking on Target " + ctb.TrackableName);
}
}
else
{
ctb.CylinderTarget.StopExtendedTracking();
}
}
else if (tb is ObjectTargetBehaviour)
{
ObjectTargetBehaviour otb = tb as ObjectTargetBehaviour;
if (extTrackingEnabled)
{
if (!otb.ObjectTarget.StartExtendedTracking())
{
success = false;
Debug.LogError("Failed to start Extended Tracking on Target " + otb.TrackableName);
}
}
else
{
otb.ObjectTarget.StopExtendedTracking();
}
}
}
mExtTrackingEnabled = success && extTrackingEnabled;
}
public void OnUpdateFrame(FrameEventArgs e, KeyboardDevice Keyboard, MouseDevice Mouse)
{
if (fadingIn)
{
fadePercent -= (float)e.Time;
if (fadePercent <= 0)
{
fadingIn = false;
}
}
if (fadingOut)
{
fadePercent += (float)e.Time;
if (fadePercent >= 1)
{
StateManager.PopState();
if (level + 1 > maxLevel)
{
StateManager.PushState(new MenuState("You escaped!", "\n\n\nPlay again?"));
}
else
{
StateManager.PushState(new GameState(level + 1));
}
}
}
float time = (float)e.Time;
bool up = Keyboard[Key.W], left = Keyboard[Key.A], down = Keyboard[Key.S], right = Keyboard[Key.D];
player.Update(time);
Entity prevCollidedWith = lastCollidedWith;
lastCollidedWith = null;
Vector2 realPrevPos = player.Position;
if (up && left)
{
player.MoveUpLeft(time);
}
else if (up && right)
{
player.MoveUpRight(time);
}
else if (down && left)
{
player.MoveDownLeft(time);
}
else if (down && right)
{
player.MoveDownRight(time);
}
else if (up)
{
player.MoveUp(time);
}
else if (left)
{
player.MoveLeft(time);
}
else if (down)
{
player.MoveDown(time);
}
else if (right)
{
player.MoveRight(time);
}
else
{
lastCollidedWith = prevCollidedWith; //if no key was pressed, restore the old one. HACK
player.moving = false;
}
if (map.IsColliding(player.BoundingBox))
{
player.Position = realPrevPos;
}
foreach (var ent in entities)
{
if (ent is Pickaxe)
{
((Pickaxe)ent).AIUpdate(player);
}
if (ent is Goblin)
{
((Goblin)ent).AIUpdate(player);
}
}
for (int i = entities.Count - 1; i >= 0; i--)
{
Entity ent = entities[i];
ent.Update(time);
if (map.IsColliding(ent.BoundingBox))
{
ent.ResetPos();
}
if (PhysicsManager.IsColliding(player.BoundingBox, ent.BoundingBox))
{
lastCollidedWith = ent;
if (ent is Generator)
{
player.Position = realPrevPos;
}
else if (ent is Lift)
{
if (((Lift)ent).enabled)
{
((Lift)ent).source.Play();
fadingOut = true;
}
}
else if (ent is Pickaxe)
{
if (((Pickaxe)ent).active)
{
entities.Remove(ent);
player.health--;
}
}
else if (ent is Goblin)
{
entities.Remove(ent);
player.health -= 2;
}
else if (ent is Endgame)
{
fadingOut = true;
}
}
}
if (Keyboard[Key.E] && lastCollidedWith != null)
{
if (lastCollidedWith is Generator)
{
((Generator)lastCollidedWith).Used = true;
player.drawShadow = false;
lift.Enable();
}
}
camera.Position = player.Position;
AudioManager.ListenerPos = new Vector3(player.Position);
if (generator != null && generator.Used)
{
for (int i = entities.Count - 1; i >= 0; i--)
{
var ent = entities[i];
if (ent is Goblin)
{
entities.Remove(ent);
}
if (ent is Pickaxe)
{
((Pickaxe)ent).active = false;
}
}
}
if (player.health <= 0)
{
StateManager.PopState();
StateManager.PushState(loseState);
}
}
public virtual InternalEntityEntry StartTracking(
IEntityType entityType,
object entity,
ValueBuffer valueBuffer)
=> StateManager.StartTrackingFromQuery(entityType, entity, valueBuffer);
public async Task <bool> CreateOrderAsync(OrderDto dto)
{
var items = await StateManager.GetOrAddAsync <IReliableDictionary2 <Guid, OrderItem> >("Orders");
ServiceEventSource.Current.ServiceMessage(Context,
"Received create order request. OrderId: {0}. ProductId: {1}. Quantity: {2}.", dto.Id, dto.ProductId, dto.Quantity);
using (ITransaction tx = StateManager.CreateTransaction())
{
var order = new OrderItem(dto);
var item = await items.AddOrUpdateAsync(tx, order.Id, order, (k, v) => order);
//remove stock
var inventoryService = RemotingProxyFactory.CreateInventoryService();
var resultRemovingStock = false;
try
{
resultRemovingStock = await inventoryService.RemoveStockAsync(dto);
}
catch (Exception ex)
{
ServiceEventSource.Current.ServiceMessage(Context, "Removing stock is error. OrderId: {0}. ProductId: {1}. Quantity: {2}. ErrorMessage: {3}.", dto.Id, dto.ProductId, dto.Quantity, ex.Message);
return(false);
}
if (resultRemovingStock)
{
ServiceEventSource.Current.ServiceMessage(Context, "Stock removed. OrderId: {0}. ProductId: {1}. Quantity: {2}.", dto.Id, dto.ProductId, dto.Quantity);
try
{
//NOTE Local transaction is failed, will to compensate
//throw new Exception("Local transaction is failed");
await tx.CommitAsync();
ServiceEventSource.Current.ServiceMessage(Context, "Order submitted. OrderId: {0}. ProductId: {1}. Quantity: {2}.", dto.Id, dto.ProductId, dto.Quantity);
return(true);
}
catch (Exception ex)
{
ServiceEventSource.Current.ServiceMessage(Context, "Submitting order is error. OrderId: {0}. ProductId: {1}. Quantity: {2}. ErrorMessage: {3}.", dto.Id, dto.ProductId, dto.Quantity, ex.Message);
//compensation, add stock, maybe with retry
try
{
await inventoryService.CompensateStockAsync(dto);
}
catch (Exception ex1)
{
//if compensating stock raise ex, just write log, then person deal with this error
ServiceEventSource.Current.ServiceMessage(Context, "Compensating stock is error. OrderId: {0}. ProductId: {1}. Quantity: {2}. ErrorMessage: {3}.", dto.Id, dto.ProductId, dto.Quantity, ex1.Message);
}
return(false);
}
}
else
{
ServiceEventSource.Current.ServiceMessage(Context, "Removing stock is failed. OrderId: {0}. ProductId: {1}. Quantity: {2}.", dto.Id, dto.ProductId, dto.Quantity);
return(false);
}
}
}
public override void Update(GameTime gameTime)
{
// Move the background
if (_backgroundMainRectangle.Y >= Config.Resolution.Y)
{
_backgroundMainRectangle.Y = _backgroundTopRectangle.Y - Config.Resolution.Y;
}
if (_backgroundTopRectangle.Y >= Config.Resolution.Y)
{
_backgroundTopRectangle.Y = _backgroundMainRectangle.Y - Config.Resolution.Y;
}
/*
* _backgroundMainRectangle.Y += (int)(250 * (float)gameTime.ElapsedGameTime.TotalSeconds);
* _backgroundTopRectangle.Y += (int)(250 * (float)gameTime.ElapsedGameTime.TotalSeconds);
*/
HandleInput();
_timer.Update(gameTime);
_playTime += gameTime.ElapsedGameTime;
if (InputHandler.PressedCancel())
{
UnloadContent();
StateManager.ChangeState(GameRef.TitleScreen);
}
base.Update(gameTime);
foreach (Player p in Players)
{
if (p.IsAlive)
{
if (p.BulletTime)
{
var newGameTime = new GameTime(
gameTime.TotalGameTime,
new TimeSpan((long)(gameTime.ElapsedGameTime.Ticks / Improvements.BulletTimeDivisorData[PlayerData.BulletTimeDivisorIndex].Key))
);
gameTime = newGameTime;
}
/*
* for (int i = 0; i < p.GetBullets().Count; i++)
* {
* p.GetBullets()[i].Update(gameTime);
*
* if (_enemy.IsAlive && _enemy.Intersects(p.GetBullets()[i]))
* {
* if (_enemy.IsReady())
* {
* _enemy.TakeDamage(p.GetBullets()[i].Power);
* hit.Play();
* p.AddScore(Improvements.ScoreByHitData[PlayerData.ScoreByHitIndex].Key);
* }
*
* p.GetBullets().Remove(p.GetBullets()[i]);
* }
* else
* {
* if (p.GetBullets()[i].X < 0 || p.GetBullets()[i].X > Config.GameArea.X ||
* p.GetBullets()[i].Y < 0 || p.GetBullets()[i].Y > Config.GameArea.Y)
* {
* p.GetBullets().Remove(p.GetBullets()[i]);
* }
* }
* }
*/
foreach (var part in _enemy.Parts)
{
if (p.Intersects(part))
{
p.Hit();
}
}
foreach (Mover m in _enemy.MoverManager.movers)
{
if (p.Intersects(m))
{
p.Hit();
}
}
p.Update(gameTime);
}
}
/*
* if (_enemy.IsAlive)
* {
* _enemy.Update(gameTime);
* }
* else
* {
* _waveNumber++;
*
* _timer.AddTime(Improvements.TimerExtraTimeData[PlayerData.TimerExtraTimeIndex].Key);
*
* _enemy.DefeatNumber++;
* _enemy.Initialize();
* }
*/
// GameRef Over
if ((!Players[0].IsAlive && (Config.PlayersNumber == 1 || (Config.PlayersNumber == 2 && !Players[1].IsAlive))) || _timer.IsFinished)
{
UnloadContent();
GameRef.GameOverScreen.Died = !_timer.IsFinished;
GameRef.GameOverScreen.Time = _playTime;
GameRef.GameOverScreen.WaveNumber = _waveNumber;
GameRef.GameOverScreen.Player1Score = Players[0].Score;
if (Config.PlayersNumber == 2)
{
GameRef.GameOverScreen.Player2Score = Players[1].Score;
}
int totalScore =
GameRef.GameOverScreen.Player1Score +
GameRef.GameOverScreen.Player2Score +
(Improvements.ScoreByEnemyData[PlayerData.ScoreByEnemyIndex].Key * GameRef.GameOverScreen.WaveNumber) +
(int)_playTime.TotalSeconds;
GameRef.GameOverScreen.TotalScore = totalScore;
PlayerData.Credits += totalScore;
StateManager.ChangeState(GameRef.GameOverScreen);
}
if (Config.Debug && InputHandler.KeyPressed(Keys.C))
{
Config.DisplayCollisionBoxes = !Config.DisplayCollisionBoxes;
}
}
/// <summary>Called when the lobby scene from Unity is loaded.</summary>
/// <param name="lvl">Id of the level loaded.</param>
/// <returns>void</returns>
public MarioState(StateManager stateManager)
: base(stateManager)
{
gameId = EnumGame.MARIO;
}
void Start()
{
mStateManager = GameObject.FindGameObjectWithTag("Manager").GetComponent <StateManager>();
mWeapon = Scene.GetWeapon();
}
public override void Update(GameTime gameTime)
{
if (InputHandler.PressedCancel())
{
StateManager.ChangeState(GameStateManager.State.TitleScreen);
}
if (InputHandler.PressedUp())
{
select.Play();
_menuIndex--;
if (_menuIndex < 0)
{
_menuIndex = _menuText.Length;
}
}
if (InputHandler.PressedDown())
{
select.Play();
_menuIndex = (_menuIndex + 1) % (_menuText.Length + 1);
}
if (InputHandler.PressedAction())
{
if (_menuIndex == _menuText.Length)
{
choose.Play();
StateManager.ChangeState(GameStateManager.State.TitleScreen);
}
bool error = false;
switch (_menuIndex)
{
// Lives
case 0:
if (!_finished["livesNumber"] &&
PlayerData.LivesNumberIndex < Improvements.LivesNumberData.Count - 1 &&
PlayerData.Credits >= Improvements.LivesNumberData[PlayerData.LivesNumberIndex + 1].Value)
{
PlayerData.Credits -= Improvements.LivesNumberData[PlayerData.LivesNumberIndex + 1].Value;
PlayerData.LivesNumberIndex++;
}
else
{
error = true;
}
break;
case 1:
if (!_finished["shootType"] &&
PlayerData.ShootTypeIndex < Improvements.ShootTypeData.Count - 1 &&
PlayerData.Credits >= Improvements.ShootTypeData[PlayerData.ShootTypeIndex + 1].Value)
{
PlayerData.Credits -= Improvements.ShootTypeData[PlayerData.ShootTypeIndex + 1].Value;
PlayerData.ShootTypeIndex++;
}
else
{
error = true;
}
break;
case 2:
if (!_finished["shootPower"] &&
PlayerData.ShootPowerIndex < Improvements.ShootPowerData.Count - 1 &&
PlayerData.Credits >= Improvements.ShootPowerData[PlayerData.ShootPowerIndex + 1].Value)
{
PlayerData.Credits -= Improvements.ShootPowerData[PlayerData.ShootPowerIndex + 1].Value;
PlayerData.ShootPowerIndex++;
}
else
{
error = true;
}
break;
case 3:
if (!_finished["shootFrequency"] &&
PlayerData.ShootFrequencyIndex < Improvements.ShootFrequencyData.Count - 1 &&
PlayerData.Credits >= Improvements.ShootFrequencyData[PlayerData.ShootFrequencyIndex + 1].Value)
{
PlayerData.Credits -= Improvements.ShootFrequencyData[PlayerData.ShootFrequencyIndex + 1].Value;
PlayerData.ShootFrequencyIndex++;
}
else
{
error = true;
}
break;
case 4:
if (!_finished["timerInitialTime"] &&
PlayerData.TimerInitialTimeIndex < Improvements.TimerInitialTimeData.Count - 1 &&
PlayerData.Credits >= Improvements.TimerInitialTimeData[PlayerData.TimerInitialTimeIndex + 1].Value)
{
PlayerData.Credits -= Improvements.TimerInitialTimeData[PlayerData.TimerInitialTimeIndex + 1].Value;
PlayerData.TimerInitialTimeIndex++;
}
else
{
error = true;
}
break;
case 5:
if (!_finished["timerExtraTime"] &&
PlayerData.TimerExtraTimeIndex < Improvements.TimerExtraTimeData.Count - 1 &&
PlayerData.Credits >= Improvements.TimerExtraTimeData[PlayerData.TimerExtraTimeIndex + 1].Value)
{
PlayerData.Credits -= Improvements.TimerExtraTimeData[PlayerData.TimerExtraTimeIndex + 1].Value;
PlayerData.TimerExtraTimeIndex++;
}
else
{
error = true;
}
break;
case 6:
if (!_finished["bulletTimeDivisor"] &&
PlayerData.InvicibleTimeIndex < Improvements.InvicibleTimeData.Count - 1 &&
PlayerData.Credits >= Improvements.InvicibleTimeData[PlayerData.InvicibleTimeIndex + 1].Value)
{
PlayerData.Credits -= Improvements.InvicibleTimeData[PlayerData.InvicibleTimeIndex + 1].Value;
PlayerData.InvicibleTimeIndex++;
}
else
{
error = true;
}
break;
case 8:
if (!_finished["bulletTime"] &&
!PlayerData.BulletTimeEnabled &&
PlayerData.Credits >= Improvements.BulletTimePrice)
{
PlayerData.Credits -= Improvements.BulletTimePrice;
PlayerData.BulletTimeEnabled = true;
}
else
{
error = true;
}
break;
case 9:
if (!_finished["bulletTimeTimer"] &&
PlayerData.BulletTimeTimerIndex < Improvements.BulletTimeTimerData.Count - 1 &&
PlayerData.Credits >= Improvements.BulletTimeTimerData[PlayerData.BulletTimeTimerIndex + 1].Value)
{
PlayerData.Credits -= Improvements.BulletTimeTimerData[PlayerData.BulletTimeTimerIndex + 1].Value;
PlayerData.BulletTimeTimerIndex++;
}
else
{
error = true;
}
break;
case 10:
if (!_finished["bulletTimeDivisor"] &&
PlayerData.BulletTimeDivisorIndex < Improvements.BulletTimeDivisorData.Count - 1 &&
PlayerData.Credits >= Improvements.BulletTimeDivisorData[PlayerData.BulletTimeDivisorIndex + 1].Value)
{
PlayerData.Credits -= Improvements.BulletTimeDivisorData[PlayerData.BulletTimeDivisorIndex + 1].Value;
PlayerData.BulletTimeDivisorIndex++;
}
else
{
error = true;
}
break;
default:
error = true;
break;
}
if (error)
{
_error = "You don't have enought credits to buy this !";
}
else
{
_error = "";
_buySound.Play();
}
UpdateMenuText();
}
base.Update(gameTime);
}
private async Task <IReliableDictionary2 <string, double> > GetDisconnectedGatewayPerformanceAsync()
{
return(await StateManager.GetOrAddAsync
<IReliableDictionary2 <string, double> >(GATEWAYPERFDIC)
.ConfigureAwait(false));
}
private void BindData()
{
if (orderId > 0)
{
Order orderData = CSWebBase.CustomOrderManager.GetOrderDetails(orderId);
List <Sku> skus = orderData.SkuItems.FindAll(x => !CSWebBase.SiteBasePage.IsKitBundleItem(x.SkuId));
foreach (Sku sku in skus)
{
if (CSWebBase.SiteBasePage.IsMainSku(sku.SkuId))
{
decimal totalPrice = sku.TotalPrice;
// add up all initial prices of all kit bundle items
foreach (Sku bundleSku in orderData.SkuItems.FindAll(x => CSWebBase.SiteBasePage.IsKitBundleItem(x.SkuId)))
{
totalPrice += bundleSku.TotalPrice;
}
sku.TotalPrice = totalPrice;
}
}
skus.Sort(new CSWebBase.SkuSortComparer());
dlordersList.DataSource = skus;
dlordersList.DataBind();
LiteralSubTotal.Text = Math.Round(orderData.SubTotal, 2).ToString();
LiteralShipping.Text = Math.Round(CSWebBase.SiteBasePage.GetShippingCost(orderData), 2).ToString();
LiteralTax.Text = Math.Round(orderData.Tax, 2).ToString();
LiteralTotal.Text = Math.Round(orderData.Total, 2).ToString();
if (orderData.RushShippingCost > 0)
{
pnlRushLabel.Visible = true;
pnlRush.Visible = true;
LiteralRushShipping.Text = Math.Round(orderData.RushShippingCost, 2).ToString();
}
if (orderData.DiscountCode.Length > 0 && (CSWebBase.SiteBasePage.FreeShipDiscountCodeMainSku ?? string.Empty).ToUpper() != orderData.DiscountCode.ToUpper())
{
if (orderData.DiscountAmount > 0)
{
pnlPromotionLabel.Visible = true;
pnlPromotionalAmount.Visible = true;
lblPromotionPrice.Text = String.Format("(${0:0.00})", orderData.DiscountAmount);
}
}
LiteralName.Text = String.Format("{0} {1}", orderData.CustomerInfo.ShippingAddress.FirstName, orderData.CustomerInfo.ShippingAddress.LastName);
LiteralEmail.Text = orderData.CustomerInfo.Email;
LiteralAddress.Text = orderData.CustomerInfo.ShippingAddress.Address1;
LiteralAddress2.Text = orderData.CustomerInfo.ShippingAddress.Address2;
LiteralCity.Text = orderData.CustomerInfo.ShippingAddress.City;
LiteralZip.Text = orderData.CustomerInfo.ShippingAddress.ZipPostalCode;
LiteralState.Text = StateManager.GetStateName(orderData.CustomerInfo.ShippingAddress.StateProvinceId);
LiteralCountry.Text = CountryManager.CountryName(orderData.CustomerInfo.ShippingAddress.CountryId);
LiteralName_b.Text = String.Format("{0} {1}", orderData.CustomerInfo.BillingAddress.FirstName, orderData.CustomerInfo.BillingAddress.LastName);
LiteralAddress_b.Text = orderData.CustomerInfo.BillingAddress.Address1;
LiteralAddress2_b.Text = orderData.CustomerInfo.BillingAddress.Address2;
LiteralCity_b.Text = orderData.CustomerInfo.BillingAddress.City;
LiteralZip_b.Text = orderData.CustomerInfo.BillingAddress.ZipPostalCode;
LiteralState_b.Text = StateManager.GetStateName(orderData.CustomerInfo.BillingAddress.StateProvinceId);
LiteralCountry_b.Text = CountryManager.CountryName(orderData.CustomerInfo.BillingAddress.CountryId);
//Google Analutics E-Commerce Pixel
//LoadGoogleAnalytics(orderData);
}
}
private async Task <IReliableDictionary2 <string, GatewayInfo> > GetGatewayInformationDictionaryAsync()
{
return(await StateManager.GetOrAddAsync
<IReliableDictionary2 <string, GatewayInfo> >(GATEWAYINFODIC)
.ConfigureAwait(false));
}
private void BindData()
{
if (orderId > 0)
{
Order orderData = CSResolve.Resolve <IOrderService>().GetOrderDetails(orderId);
List <Sku> skus = orderData.SkuItems;
skus.Sort(new CSWebBase.SkuSortComparer());
dlordersList.DataSource = skus;
dlordersList.DataBind();
LiteralSubTotal.Text = Math.Round(orderData.SubTotal, 2).ToString();
LiteralShipping.Text = Math.Round(orderData.ShippingCost, 2).ToString();
LiteralTax.Text = Math.Round(orderData.Tax, 2).ToString();
LiteralTotal.Text = Math.Round(orderData.Total, 2).ToString();
if (orderData.RushShippingCost > 0)
{
pnlRushLabel.Visible = true;
pnlRush.Visible = true;
LiteralRushShipping.Text = Math.Round(orderData.RushShippingCost, 2).ToString();
}
if (orderData.DiscountCode.Length > 0)
{
pnlPromotionLabel.Visible = true;
pnlPromotionalAmount.Visible = true;
lblPromotionPrice.Text = String.Format("(${0:0.00})", orderData.DiscountAmount);
}
LiteralName.Text = String.Format("{0} {1}", orderData.CustomerInfo.ShippingAddress.FirstName, orderData.CustomerInfo.ShippingAddress.LastName);
LiteralEmail.Text = orderData.CustomerInfo.Email;
LiteralAddress.Text = orderData.CustomerInfo.ShippingAddress.Address1;
LiteralAddress2.Text = orderData.CustomerInfo.ShippingAddress.Address2;
if (LiteralAddress2.Text.Equals(""))
{
phSAddress2.Visible = false;
}
else
{
phSAddress2.Visible = true;
}
LiteralCity.Text = orderData.CustomerInfo.ShippingAddress.City;
LiteralZip.Text = orderData.CustomerInfo.ShippingAddress.ZipPostalCode;
LiteralState.Text = StateManager.GetStateName(orderData.CustomerInfo.ShippingAddress.StateProvinceId);
LiteralCountry.Text = CountryManager.CountryName(orderData.CustomerInfo.ShippingAddress.CountryId);
LiteralName_b.Text = String.Format("{0} {1}", orderData.CustomerInfo.BillingAddress.FirstName, orderData.CustomerInfo.BillingAddress.LastName);
LiteralAddress_b.Text = orderData.CustomerInfo.BillingAddress.Address1;
LiteralAddress2_b.Text = orderData.CustomerInfo.BillingAddress.Address2;
if (LiteralAddress2_b.Text.Equals(""))
{
pnlBAddress2.Visible = false;
}
else
{
pnlBAddress2.Visible = true;
}
LiteralCity_b.Text = orderData.CustomerInfo.BillingAddress.City;
LiteralZip_b.Text = orderData.CustomerInfo.BillingAddress.ZipPostalCode;
LiteralState_b.Text = StateManager.GetStateName(orderData.CustomerInfo.BillingAddress.StateProvinceId);
LiteralCountry_b.Text = CountryManager.CountryName(orderData.CustomerInfo.BillingAddress.CountryId);
LiteralPhone.Text = orderData.CustomerInfo.BillingAddress.PhoneNumber;
//Google Analutics E-Commerce Pixel
//LoadGoogleAnalytics(orderData);
}
}
Task <string> IBoard.Details()
{
return(StateManager.GetStateAsync <string>("Name"));
}
/// <summary>
/// TODO: Replace with your own actor method.
/// </summary>
/// <returns></returns>
Task <int> INetCoreActor.GetCountAsync(CancellationToken cancellationToken)
{
return(StateManager.GetStateAsync <int>(StateNameCount, cancellationToken));
}
public GameState(IStateManager stateManager)
: base(stateManager)
{
var blocks = StateManager.Game.ContentManager.LoadTexture("blocks.png");
var sun = StateManager.Game.ContentManager.LoadTexture("sun.png");
var background = StateManager.Game.ContentManager.LoadTexture("background.png");
var sixteen = StateManager.Game.ContentManager.LoadTexture("16x16.png");
var airMeter = new Texture2D(stateManager.Game.GraphicsDevice, 256, 4);
airMeter.Fill(Color.White);
_pickUpKey = StateManager.Game.ContentManager.LoadSfx("pick.wav");
_die = StateManager.Game.ContentManager.LoadSfx("die.wav");
_jump = StateManager.Game.ContentManager.LoadSfx("jump.wav");
_font = new SpectrumFont(StateManager.Game.ContentManager.LoadTexture("font.png"));
_roomRenderer = new RoomBlocks(blocks, background, sun);
_air = StateManager.Game.ContentManager.LoadImage("titleair.bmp");
_lives = new LivesIndicator(sixteen);
_baddieRenderer = new BaddieRenderer(sixteen);
_willy = new MinerWillyRenderer(sixteen, background);
_exit = new ExitRenderer(sixteen);
_airMeter = new AirRenderer(airMeter);
_scoreRenderer = new ScoreRenderer(StateManager.Game.ContentManager.LoadTexture("font.png"));
_pauseables.Add(_willy);
_pauseables.Add(_baddieRenderer);
_pauseables.Add(_roomRenderer);
_pauseables.Add(_exit);
var blackBackground = new Texture2D(StateManager.Game.GraphicsDevice, 128, 24);
blackBackground.Fill(Color.Black);
_quitGameRenderer = new QuitGame(StateManager.Game.ContentManager.LoadTexture("font.png"), blackBackground);
_quitGameRenderer.Hidden = true;
_willy.IncrementScore += Score_Update;
_willy.Jumping += Willy_Jumping;
_willy.OnDeath += Willy_Death;
_pauseKey = new KeyUp(Keys.P, () =>
{
StateManager.ChangeState("paused", _roomId);
});
_quitKey = new KeyUp(Keys.Escape, () =>
{
ToggleQuit(!_quitShowing);
});
_yesKey = new KeyUp(Keys.Y, () =>
{
ToggleQuit(false);
StateManager.ChangeState("title");
});
_noKey = new KeyUp(Keys.N, () =>
{
ToggleQuit(false);
});
}
/// <summary>
/// TODO: Replace with your own actor method.
/// </summary>
/// <param name="count"></param>
/// <returns></returns>
Task INetCoreActor.SetCountAsync(int count, CancellationToken cancellationToken)
{
// Requests are not guaranteed to be processed in order nor at most once.
// The update function here verifies that the incoming count is greater than the current count to preserve order.
return(StateManager.AddOrUpdateStateAsync(StateNameCount, count, (key, value) => count > value ? count : value, cancellationToken));
}
public WelcomeState(StateManager manager)
{
this._statemanager = manager;
}
public abstract void Update(GameTime gameTime, StateManager screen,
GamePadState gamePadState, MouseState mouseState,
KeyboardState keyState, InputHandler input);
private void Start()
{
stateManager = GameObject.FindGameObjectWithTag("Managers").GetComponent <StateManager>();
timerText = gameObject.GetComponent <Text>();
}
void PlayerAuthenticated(object sender, EventArgs e)
{
_loader.Stop();
StateManager.OnPlayerLoggedIn();
}
