public Client()
{
var factory = new StateFactory();
var first = new State1(factory, this);
CurrentState = factory.GetOrCreate <State1>(() => first);
}
private void NodeChosen(Node node, GameInfo gameInfo, IGameState waitState)
{
gameInfo.Fsm.Remove(waitState);
gameInfo.ClearTargets();
gameInfo.PanCameraToObject(gameInfo.CurrentPlayer);
var currentPlayer = gameInfo.CurrentPlayer;
currentPlayer.NextNode = node;
// Give the player a passport for the island they are going to arrive at
var assetResponse = currentPlayer.Accept(new PassportStamp(((Travel)node.BindedLogic.PureLogic).IslandType));
// Give the player a car modification if required
currentPlayer.SetTransport(TransportType);
if (assetResponse == AssetResponse.CollectedAllPassportStamps)
{
if (gameInfo.GameRuleType == GameRuleType.Passport)
{
gameInfo.Fsm.LazyPush(StateFactory.GetState(GameStates.GameStates.EndGame));
}
}
gameInfo.CreateMessage(String.Format("You have been given a {0} passport token!", IslandType));
gameInfo.Fsm.Push(StateFactory.GetState(GameStates.GameStates.VisuallyMovePlayer));
}
public void StoryCardLogicTest()
{
StoryCardData target = new StoryCardData();
var stories = StoryCardData.PopulateStoryCards();
StateFactory.SetInstance(new StateFactory());
StateFactory.AddFactory(GameStates.Wait, new WaitFactory());
var gameTime = new GameTime();
var player = new Player();
player.Initialize();
player.Accept(new Transport(TransportType.Car, String.Empty, int.MaxValue, null, null, 0));
var world = new List <WorldObject> {
new StartingNode(Vector2.Zero), new Spinner(Vector2.Zero)
};
var gameInfo = new GameInfo(world, new[] { player }, 100, GameRuleType.Retirement);
gameInfo.GetNextPlayer();
foreach (var story in stories)
{
var performingLogic = story.PureLogic;
Assert.IsNotNull(performingLogic);
try {
var returnedStates = story.PureLogic.PerformLogic(gameTime, gameInfo);
} catch (Exception e) {
Console.WriteLine(e);
}
}
}
/// <summary>
///
/// </summary>
void LoadContent()
{
SafeDispose(ref factory);
SafeDispose(ref vertexBuffers);
SafeDispose(ref indexBuffers);
surfaceShader = Game.Content.Load <Ubershader>("surface");
factory = new StateFactory(surfaceShader, typeof(SurfaceFlags), Primitive.TriangleList, VertexInputElement.FromStructure <VertexColorTextureTBN>());
scene = Game.Content.Load <Scene>(@"Scenes\testScene");
vertexBuffers = scene.Meshes
.Select(mesh => VertexBuffer.Create(Game.GraphicsDevice, mesh.Vertices.Select(v => VertexColorTextureTBN.Convert(v)).ToArray()))
.ToArray();
indexBuffers = scene.Meshes
.Select(mesh => IndexBuffer.Create(Game.GraphicsDevice, mesh.GetIndices()))
.ToArray();
surfaceProps = scene.Materials
.Select(mtrl => new SurfaceProperties()
{
Diffuse = LoadTexture2D(mtrl.TexturePath, "|srgb", defaultDiffuse),
Specular = LoadTexture2D(mtrl.TexturePath, "_spec", defaultSpecular),
NormalMap = LoadTexture2D(mtrl.TexturePath, "_local", defaultNormalMap),
Emission = LoadTexture2D(mtrl.TexturePath, "_glow|srgb", defaultEmission),
})
.ToArray();
}
public Robot(ITable table, int lateralSpeed, IDisplayConsole displayConsole)
{
Table = table;
LateralSpeed = lateralSpeed;
CurrentState = StateFactory.CreateInactive(this);
_displayConsole = displayConsole;
}
private void BStart_Click(object sender, EventArgs e)
{
skills = new SkillManager(keyEvents, this);
stateFactory = new StateFactory(this, keyEvents, skills, this);
currentState = stateFactory.NewState <Searching>();
PlayerTimer.Start();
}
public override void doAction(Comedian bot)
{
//Go to Sleep State if bedtime
if ((bot.WakeTime > bot.SleepTime && (DateTime.Now.TimeOfDay < bot.WakeTime && DateTime.Now.TimeOfDay >= bot.SleepTime)) || (bot.WakeTime < bot.SleepTime && (DateTime.Now.TimeOfDay < bot.WakeTime || DateTime.Now.TimeOfDay >= bot.SleepTime)))
{
attentionCounter = ++attentionCounter % 4;
if (attentionCounter == 0) //8 seconds elapsed
{
//Say Good Night
lock (bot.OutgoingMessage)
{
bot.OutgoingMessage.Enqueue(new ChatMessage(bot.PSource, bot.retrieve(bot.PSource)[0], bot.PSource.MasterAccount, new TextMessage(getAIMLResponse("SayStatementPattern sleepy", getPrimaryUser(bot), bot))));
}
bot.setNextState(StateFactory.getBotState("Sleep", bot));
}
}
else if ((bot.OffWorkTime > bot.WorkTime && (DateTime.Now.TimeOfDay < bot.OffWorkTime && DateTime.Now.TimeOfDay >= bot.WorkTime)) || (bot.OffWorkTime < bot.WorkTime && (DateTime.Now.TimeOfDay < bot.OffWorkTime || DateTime.Now.TimeOfDay >= bot.WorkTime)))
{
attentionCounter = ++attentionCounter % 30;
if (attentionCounter == 0) //1 minute elapsed
{
//Say Time for Work
lock (bot.OutgoingMessage)
{
bot.OutgoingMessage.Enqueue(new ChatMessage(bot.PSource, bot.retrieve(bot.PSource)[0], bot.PSource.MasterAccount, new TextMessage(getAIMLResponse("SayStatementPattern time for work", getPrimaryUser(bot), bot))));
}
bot.setNextState(StateFactory.getBotState("Busy", bot));
}
}
}
public override IGameState[] PerformLogic(GameTime gameTime, GameInfo gameInfo)
{
var currentPlayer = gameInfo.CurrentPlayer;
currentPlayer.CareerType = CareerType.CollegeCareer;
// Test if they're already taken the exam before
if (currentPlayer.PassedExam)
{
return(null);
}
var waitState = StateFactory.GetState(GameStates.GameStates.Wait);
if (currentPlayer.CurrentlyTakingExam)
{
return(TestPassedExamLogic(gameInfo, waitState));
}
if (currentPlayer.CareerType != CareerType.CollegeCareer)
{
return(CreateAlert(gameInfo, waitState, "You can only take an exam if you took college path", icon: "Images/AlertIcons/Fail"));
}
// Strip their roll amount;
currentPlayer.RollAmount = 0;
// Set their taking exam boolean to be true
currentPlayer.CurrentlyTakingExam = true;
return(TakeExamLogic(gameInfo));
}
public async Task TimerTest()
{
await using var serving = await WebSocketHost.ServeAsync();
var tp = Services.GetRequiredService <ITimeService>();
var pub = await Publisher.PublishAsync(_ => tp.GetTimeAsync());
var rep = Replicator.GetOrAdd <DateTime>(pub.Ref);
await rep.RequestUpdateAsync().AsAsyncFunc()
.Should().CompleteWithinAsync(TimeSpan.FromMinutes(1));
var count = 0;
using var state = StateFactory.NewLive <DateTime>(
o => o.WithZeroUpdateDelay(),
async(_, ct) => await rep.Computed.UseAsync(ct));
state.Updated += s => {
Out.WriteLine($"Client: {s.Value}");
count++;
};
await TestEx.WhenMet(
() => count.Should().BeGreaterThan(2),
TimeSpan.FromSeconds(5));
}
public override void doAction(Comedian bot)
{
if ((bot.WakeTime > bot.SleepTime && (DateTime.Now.TimeOfDay >= bot.WakeTime || DateTime.Now.TimeOfDay < bot.SleepTime)) || (bot.WakeTime < bot.SleepTime && (DateTime.Now.TimeOfDay >= bot.WakeTime && DateTime.Now.TimeOfDay < bot.SleepTime)))
{
bot.setNextState(StateFactory.getBotState("Greeting", bot));
}
}
/// <summary>
/// Load content
/// </summary>
public void LoadContent()
{
uberShader = Content.Load <Ubershader>("render");
factory = new StateFactory(uberShader, typeof(RenderFlags), Primitive.TriangleList, VertexInputElement.FromStructure <CubeVertex>());
texture = Content.Load <Texture2D>(@"Scenes\lena");
vb = new VertexBuffer(GraphicsDevice, typeof(CubeVertex), 24);
ib = new IndexBuffer(GraphicsDevice, 36);
// create a new space with physics
space = new Space();
// update gravity force
space.ForceUpdater.Gravity = new Vector3BEPU(0, -9.81f, 0);
// add ground, ground has infinite mass
Box ground = new Box(new Vector3BEPU(0, 0, 0), 50, 1, 50);
space.Add(ground);
// create boxes with random position and add color as a tag, then add box to space
for (int i = 0; i < numberOfBoxes; i++)
{
Vector3Fusion vector = RandomExt.NextVector3(random, new Vector3Fusion(-10, 20, -10), new Vector3Fusion(10, 80, 10));
Box box = new Box(new Vector3BEPU(vector.X, vector.Y, vector.Z), 1, 1, 1, 1);
box.Tag = RandomExt.NextColor(random);
space.Add(box);
}
}
/// <summary>
///
/// </summary>
void LoadContent()
{
SafeDispose(ref factory);
skySphere = Game.Content.Load <Scene>("skySphere");
cloudSphere = Game.Content.Load <Scene>("cloudSphere");
clouds = Game.Content.Load <Texture2D>("clouds|srgb");
cirrus = Game.Content.Load <Texture2D>("cirrus|srgb");
noise = Game.Content.Load <Texture2D>("cloudNoise");
arrows = Game.Content.Load <Texture2D>("arrowsAll");
vertexBufferBlur = new VertexBuffer(Game.GraphicsDevice, typeof(VertexColorTextureTBN), 6);
vertexBuffers = skySphere.Meshes
.Select(mesh => VertexBuffer.Create(Game.GraphicsDevice, mesh.Vertices.Select(v => VertexColorTextureTBN.Convert(v)).ToArray()))
.ToArray();
indexBuffers = skySphere.Meshes
.Select(mesh => IndexBuffer.Create(Game.GraphicsDevice, mesh.GetIndices()))
.ToArray();
cloudVertexBuffers = cloudSphere.Meshes
.Select(mesh => VertexBuffer.Create(Game.GraphicsDevice, mesh.Vertices.Select(v => VertexColorTextureTBN.Convert(v)).ToArray()))
.ToArray();
cloudIndexBuffers = cloudSphere.Meshes
.Select(mesh => IndexBuffer.Create(Game.GraphicsDevice, mesh.GetIndices()))
.ToArray();
sky = Game.Content.Load <Ubershader>("sky");
factory = new StateFactory(sky, typeof(SkyFlags), (ps, i) => EnumFunc(ps, (SkyFlags)i));
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void InstancingDemo_Reloading(object sender, EventArgs e)
{
SafeDispose(ref factory);
us = Content.Load <Ubershader>("test");
factory = new StateFactory(us, typeof(UberFlags), Primitive.TriangleList, VertexInputElement.FromStructure(typeof(Vertex)), BlendState.Additive, RasterizerState.CullNone, DepthStencilState.None);
tex = Content.Load <Texture2D>("block");
}
public Form1()
{
InitializeComponent();
DoubleBuffered = true;
_state = StateFactory.GetPawnStartingState(8, 8);
}
public void LoadContent()
{
effect = Game.Content.Load <Ubershader>("debugRender.hlsl");
factory = effect.CreateFactory(typeof(RenderFlags), (ps, i) => Enum(ps, (RenderFlags)i));
//factory = effect.CreateFactory( typeof(RenderFlags), Primitive.LineList, VertexInputElement.FromStructure( typeof(LineVertex) ), BlendState.AlphaBlend, RasterizerState.CullNone, DepthStencilState.Default );
}
public ErrorState(GumballMachine gumballMachine, StateFactory stateFactory, Exception exception = null)
: base(gumballMachine, stateFactory)
{
_exception = exception;
_name = this.GetType().Name;
Console.WriteLine($"[{_name}] Manager informed that machine is in error state.");
}
public ActionsOr(Path path = null)
{
StateFactory.ValidateType(typeof(T));
this.Path = path ?? Path.Root;
this.Tag = 0;
this.Variant = new Actions(this.Path.GetNested(0));
}
public Account(string n, int firstDeposit = 0)
{
_name = n;
balance = firstDeposit;
// Simplifying Method Calls - Replace Constructor with Factory Method
_state = StateFactory.CreateAccount(firstDeposit, this);
}
public Maybe(Path path = null)
{
StateFactory.ValidateType(typeof(T));
this.Path = path ?? Path.Root;
this.Tag = 0;
this.Variant = new None(this.Path.GetNested(0));
}
public async Task StandaloneComputedTest()
{
var users = Services.GetRequiredService <IUserService>();
var time = Services.GetRequiredService <ITimeService>();
var u = new User()
{
Id = int.MaxValue,
Name = "Chuck Norris",
};
await users.CreateAsync(u, true);
using var sText = await StateFactory.NewLive <string>(
o => o.WithInstantUpdates(),
async (s, cancellationToken) => {
var norris = await users.TryGetAsync(int.MaxValue, cancellationToken).ConfigureAwait(false);
var now = await time.GetTimeAsync().ConfigureAwait(false);
return($"@ {now:hh:mm:ss.fff}: {norris?.Name ?? "(none)"}");
}).UpdateAsync(false);
sText.Updated += (s, _) => Log.LogInformation($"{s.Value}");
for (var i = 1; i <= 10; i += 1)
{
u.Name = $"Chuck Norris Lvl{i}";
await users.UpdateAsync(u);
await Task.Delay(100);
}
var text = await sText.UseAsync();
text.Should().EndWith("Lvl10");
}
public async Task SuppressTest()
{
var time = Services.GetRequiredService <ITimeService>();
var count1 = 0;
var count2 = 0;
#pragma warning disable 1998
var s1 = await StateFactory.NewComputed <int>(async (s, ct) => count1++).UpdateAsync(false);
var s2 = await StateFactory.NewComputed <int>(async (s, ct) => count2++).UpdateAsync(false);
#pragma warning restore 1998
var s12 = await StateFactory.NewComputed <(int, int)>(
async (s, cancellationToken) => {
var a = await s1.UseAsync(cancellationToken);
using var _ = Computed.Suppress();
var b = await s2.UseAsync(cancellationToken);
return(a, b);
}).UpdateAsync(false);
var v12a = await s12.UseAsync();
s1.Computed.Invalidate(); // Should increment c1 & impact c12
var v12b = await s12.UseAsync();
v12b.Should().Be((v12a.Item1 + 1, v12a.Item2));
s2.Computed.Invalidate(); // Should increment c2, but shouldn't impact c12
var v12c = await s12.UseAsync();
v12c.Should().Be(v12b);
}
void GenerateSprite(Node node)
{
if (node.GetType() == typeof(HouseNode))
{
var houseSprite = Instantiate(housePrefab) as GameObject;
houseSprite.name = "HouseNode#" + node.nodeId;
houseSprite.transform.position = node.coordinates;
}
else
{
var isRoot = ((SwitchNode)node).isRoot;
var switchPrefab = Instantiate(isRoot? rootObject : switchableObject) as GameObject;
var handler = switchPrefab.GetComponent <SwitchHandler>();
switchPrefab.name = node.nodeId;
if (!isRoot)
{
((SwitchNode)node).switchObject.state = StateFactory.Create(handler.currentIndex);
}
if (handler != null)
{
Subscribe(handler);
}
switchPrefab.transform.position = node.coordinates;
(node as SwitchNode).childs.ForEach((Node switchNodeChild) =>
{
GenerateSprite(switchNodeChild);
});
}
}
private void Start()
{
//Set up state machine
Dictionary <EnemyAIStateType, BaseState> stateMachineDictionary = new Dictionary <EnemyAIStateType, BaseState>();
foreach (EnemyAIStateType state in EnemyStates)
{
stateMachineDictionary.Add(state, StateFactory.CreateBaseState(state, this));
}
stateMachine = new EnemyAIStateMachine(stateMachineDictionary);
TargetDestination = null;
enemyController = GetComponent <Enemy>();
MovementData = (EnemyMovementData)enemyController.GetFiringData();
navMeshAgent = GetComponent <NavMeshAgent>();
//navMeshAgent.updateRotation = false;
navMeshAgent.acceleration = MovementData.NavMeshAcceleration; // 8; //enemy
navMeshAgent.angularSpeed = MovementData.NavMeshAngularSpeed; //120; // enemy
navMeshAgent.speed = MovementData.NavMeshVelocity; //3; //
//Events
enemyController.UpdateTargetedPlayer += EnemyController_UpdateTargetedPlayer;
bulletDetector.AddDangerousBullet += BulletDetector_AddDangerousBullet;
}
/// <summary>
///
/// </summary>
void LoadContent()
{
stereo = Game.Content.Load <Ubershader>("stereo");
SafeDispose(ref factory);
factory = stereo.CreateFactory(typeof(Flags), Primitive.TriangleList, VertexInputElement.Empty, BlendState.Opaque, RasterizerState.CullNone, DepthStencilState.None);
}
public IGameState[] PerformLogic(GameTime gameTime, GameInfo gameInfo)
{
var currentPlayer = gameInfo.CurrentPlayer;
var currentNode = currentPlayer.CurrentNode;
var returnedGameStates = new List <IGameState> {
StateFactory.GetState(GameStates.EndExecute)
};
if (currentNode.HasStopLogic)
{
// TODO
currentPlayer.RollAmount = 0;
}
// TODO might not work anymore
if (currentNode.HasPassingLogic || currentNode.HasStopLogic || currentNode.HasBeginningLogic || currentPlayer.RollAmount <= 1)
{
returnedGameStates.Add(currentNode.BindedLogic);
}
return(returnedGameStates.ToArray());
}
public async Task AutoRecomputeTest()
{
var time = Services.GetRequiredService <ITimeService>();
var c = await Computed.CaptureAsync(
_ => time.GetTimeWithOffsetAsync(TimeSpan.FromSeconds(1)));
var count = 0L;
using var state = StateFactory.NewLive <DateTime>(
o => o.WithZeroUpdateDelay(),
async(_, ct) => await c.UseAsync(ct));
state.Updated += s
=> Log.LogInformation($"{++count} -> {s.Value:hh:mm:ss:fff}");
await TestEx.WhenMet(
() => count.Should().BeGreaterThan(2),
TimeSpan.FromSeconds(5));
var lastCount = count;
state.Dispose();
await Task.Delay(1000);
count.Should().Be(lastCount);
}
/// <summary>
///
/// </summary>
void LoadContent()
{
shader = Game.Content.Load <Ubershader>("hdr");
//noiseTex = Game.Content.Load<DiscTexture>(@"noise\hdrDitherNoise");
//noiseTex = Game.Content.Load<DiscTexture>(@"noise\bayerMatrix8x8");
factory = shader.CreateFactory(typeof(Flags), Primitive.TriangleList, VertexInputElement.Empty, BlendState.Opaque, RasterizerState.CullNone, DepthStencilState.None);
}
public GumballMachine(int numberOfGumballs)
{
_name = this.GetType().Name;
_stateFactory = new StateFactory(this);
_stateFactory.SetStartingState(_stateFactory.GetNoCoinState());
LoadNextState();
AddGumballs(numberOfGumballs);
}
void Game_Reloading(object sender, EventArgs e)
{
SafeDispose(ref factory);
texture = Game.Content.Load <Texture2D>("particle2");
shader = Game.Content.Load <Ubershader>("test");
factory = new StateFactory(shader, typeof(Flags), (ps, i) => EnumAction(ps, (Flags)i));
}
public ParseEngine(Grammar grammar, ParseEngineOptions options)
{
Grammar = grammar;
Options = options;
NodeSet = new ForestNodeSet();
StateFactory = new StateFactory(DottedRules);
Initialize();
}
protected StateManager()
{
//Initialize variable
m_Factory = null;
m_Running = true;
m_Touches = new FTouch[] {};
m_Initialized = false;
m_RemovalDepth = 0;
//Listen
ListenForUpdate(onUpdate);
ListenForResize(onResize);
EnableMultiTouch();
}
public void setup(StateFactory factory)
{
//Set factory
m_Factory = factory;
}
/// <summary>
///
/// </summary>
void LoadContent ()
{
stereo = Game.Content.Load<Ubershader>("stereo");
factory = stereo.CreateFactory( typeof(Flags), Primitive.TriangleList, VertexInputElement.Empty, BlendState.Opaque, RasterizerState.CullNone, DepthStencilState.None );
}
