public bool OnSuccess(ChallengeManager.TrackingContext ctx)
{
Log.Unity($"PASSED challenge {cr.Description}");
//This saves completion. Needs to be done locally in case of continuations.
//The callback will handle replaying.
var record = Requester.MakeGameRecord(ctx.cm.ChallengePhotos.ToArray());
Requester.TrySave(record);
if (Requester.replay == null && cr.NextChallenge(Requester.metadata).Try(out var nextC))
{
Log.Unity($"Autoproceeding to next challenge: {nextC.Description}");
var nextGr = new InstanceRequest(Requester.cb, Requester.metadata, new InstanceLowRequest(nextC), null);
nextGr.SetupInstance();
Replayer.Cancel(); //can't replay both scenes together,
//or even just the second scene due to time-dependency of world objects such as shots
ctx.cm.TrackChallenge(new SceneChallengeReqest(nextGr, nextC), ctx.onSuccess);
ctx.cm.LinkBoss(ctx.exec);
return(false);
}
else
{
UIManager.MessageChallengeEnd(true, out _);
//The callback should have a wait procedure in it
ctx.onSuccess(record);
//WaitingUtils.WaitThenCB(ctx.cm, Cancellable.Null, t, false, () => ctx.onSuccess(record));
return(true);
}
}
public CamController_RoadRunner(Transform Cam, Transform Car, Replayer rep, List <RecFrameData> PlayerFrames)
{
_car = Car;
_trCam = Cam;
_replayer = rep;
_playerFrames = PlayerFrames;
}
public static void Main(string[] args)
{
var player = new Replayer();
player.UseGraphQl(typeof(Config));
if (args.Length != 1)
{
Console.WriteLine("ZES.Replayer log.json");
}
var logFile = args[0];
var task = Task.Run(() => player.Replay(logFile));
var result = task.Result;
Console.WriteLine($"{result.Result}, replay took {result.Elapsed} ms");
if (!result.Result)
{
Console.WriteLine($"Mismatch in output : {result.Difference}");
}
var name = logFile.Split('.')[0];
using (var sw = new StreamWriter($"{name}_output.json"))
{
sw.WriteLine(result.Output);
}
}
private void OnSelectedEventChanged(object sender, TracefileEventChangedEventArgs e)
{
if (_selectionService.SelectedEvent == null)
{
return;
}
var dispatcher = Dispatcher.CurrentDispatcher;
var swapChainPresenter = new WpfSwapChainPresenter(dispatcher);
var replayer = new Replayer(
_frame, _selectionService.SelectedEvent.Model,
swapChainPresenter);
Task.Factory.StartNew(() =>
{
replayer.Replay();
DepthStencilView depthStencilView; RenderTargetView[] renderTargetViews;
replayer.Device.ImmediateContext.OutputMerger.GetTargets(
out depthStencilView, out renderTargetViews);
var activeRenderTargetView = renderTargetViews[0];
_activeRenderTarget = (Texture2D)activeRenderTargetView.Resource;
ActiveRenderTargetViewIdentifier = activeRenderTargetView.ID;
NotifyOfPropertyChange(() => ActiveRenderTargetArraySlices);
ActiveRenderTargetArraySlice = 0;
});
}
/// <summary>
/// Use this to replay your captured memoised data in sequence...
/// </summary>
/// <param name="container"></param>
/// <param name="storagePath"></param>
/// <typeparam name="S">Interface</typeparam>
protected virtual AbstractAcceptanceTest <U> RegisterServiceForReplay <S>(UnityContainer container, string storagePath)
{
var instance = new Replayer <S>(_loggerFactory, storagePath);
container.RegisterInstance(instance.Object);
return(this);
}
public CamController_Stop(Transform Cam, Transform Car, Replayer rep, CarStop stp)
{
_car = Car;
_trCam = Cam;
_replayer = rep;
_stp = stp;
FutureFrame = stp.EndFrame;
_ccf = _trCam.parent;
_goCamBox = new GameObject();
_goCamBox.transform.position = stp.CamPos;
_goCamBox.transform.localRotation = Quaternion.identity;
_trCam.position = stp.CamPos;
_trCam.SetParent(_goCamBox.transform);
_trCam.LookAt(stp.LookPos);
_goCamBox.layer = 14;
BoxCollider c = _goCamBox.AddComponent <BoxCollider>();
c.center = Vector3.zero;
c.size = new Vector3(0.1f, stp.TripodHeight * 2, 0.1f);
_rbCamBox = _goCamBox.AddComponent <Rigidbody>();
_rbCamBox.isKinematic = true;
_tripod = GameObject.CreatePrimitive(PrimitiveType.Cube);
_tripod.transform.localScale = new Vector3(1, 0.2f, 1);
_tripod.transform.position = stp.CamPos - (stp.TripodHeight - 0.052f) * Vector3.up;
_tripod.GetComponent <MeshRenderer>().enabled = false;
_collCar = _car.gameObject.AddComponent <BoxCollider>();
_collCar.center = Vector3.up * 0.8f;
_collCar.size = new Vector3(2, 1.2f, 4);
Debug.Log("StopJit constructor TripodHeight = " + stp.TripodHeight.ToString() + " " + Cam.name);
}
public void EndToEndTest()
{
// Arrange.
var device = new Device();
var logger = new TracefileBuilder(device);
var expectedData = RenderScene(device);
var stringWriter = new StringWriter();
logger.WriteTo(stringWriter);
var loggedJson = stringWriter.ToString();
var logReader = new StringReader(loggedJson);
var tracefile = Tracefile.FromTextReader(logReader);
// Act.
var swapChainPresenter = new RawSwapChainPresenter();
var replayer = new Replayer(
tracefile.Frames[0], tracefile.Frames[0].Events.Last(),
swapChainPresenter);
replayer.Replay();
var actualData = swapChainPresenter.Data;
// Assert.
Assert.That(actualData, Is.EqualTo(expectedData));
}
private void OnSelectedPixelChanged(object sender, PixelChangedEventArgs e)
{
FrameNumber = _selectionService.SelectedFrame.Number;
PixelLocation = e.SelectedPixel;
HasSelectedPixel = true;
_pixelEvents.Clear();
var swapChainPresenter = new WpfSwapChainPresenter(Dispatcher.CurrentDispatcher);
var replayer = new Replayer(
_selectionService.SelectedFrame.Model, _selectionService.SelectedEvent.Model,
swapChainPresenter,
_selectionService.SelectedFrame.ActiveRenderTargetViewIdentifier,
_selectionService.SelectedFrame.ActiveRenderTargetArraySlice,
e.SelectedPixel.X, e.SelectedPixel.Y);
Task.Factory.StartNew(() =>
{
replayer.Replay();
var events = replayer.Logger.GetPixelHistoryEvents(_selectionService.SelectedFrame.Number);
_pixelEvents.AddRange(events.Select(x => new PixelHistoryEventViewModel(x)));
FinalFrameBufferColor = ((ColorResultViewModel)_pixelEvents.Last(x => x.Result is ColorResultViewModel).Result).Result;
});
}
private void Start()
{
if (GameObject.Find("Replayer") != null)
{
replayer = GameObject.Find("Replayer").GetComponent <Replayer>();
}
savedTextures = new Dictionary <string, Texture2D>();
skipCount = 2;
}
protected async Task <ReplayResult> Replay(string logFile)
{
var player = new Replayer();
lock (_lock)
player.UseGraphQl(Configs, _logger);
var result = await player.Replay(logFile);
return(result);
}
public Replaying(MainWindow mainWindow, string filename, Replayer replayer)
: base(mainWindow)
{
bodyViewport = new BodyViewport(mainWindow.BodyViewport);
this.filename = filename;
this.replayer = replayer;
this.replayer.Start();
replayer.BodyFrameUpdated += Recorder_BodyFrameUpdated;
mainWindow.ReplayButton.Content = Resources.StopReplay;
mainWindow.ReplayButton.Click += ReplayButton_Click;
mainWindow.ExportAsBvhButton.Click += ExportAsBvhButton_Click;
}
private void ReplayButton_Click(object sender, RoutedEventArgs e)
{
var dialog = new OpenFileDialog()
{
Filter = "Mokap Record Files|*.mkp",
};
if (dialog.ShowDialog() == true)
{
var replayer = new Replayer(dialog.FileName, MainWindow.Dispatcher);
// TODO Check if replayer can start
Become(new Replaying(MainWindow, dialog.FileName, replayer));
}
else
{
logger.Trace("User cancelled load mkp file");
}
}
public override void RegularUpdate()
{
if (ETime.FirstUpdateForScreen)
{
if (Input.GetKeyDown(KeyCode.G))
{
if (state == ReplayHelperState.RECORDING)
{
var r = Replayer.End(null);
SaveData.Replays.SaveReplayFrames(saveReplayTo, r !.Value.frames());
state = ReplayHelperState.NONE;
}
else
{
Replayer.BeginRecording();
state = ReplayHelperState.RECORDING;
}
}
}
}
private void OnSelectedEventChanged(object sender, TracefileEventChangedEventArgs e)
{
NotifyOfPropertyChange(() => SelectedEvent);
if (_selectionService.SelectedEvent == null)
{
return;
}
var swapChainPresenter = new WpfSwapChainPresenter(Dispatcher.CurrentDispatcher);
var replayer = new Replayer(
_selectionService.SelectedFrame.Model, _selectionService.SelectedEvent.Model,
swapChainPresenter);
//Task.Factory.StartNew(() =>
//{
// replayer.Replay();
//});
}
protected override void OnStart(string[] args)
{
try
{
if (Advanced.Default.StartDebuggerOnStart)
{
Debugger.Launch();
while (!Debugger.IsAttached)
{
// Waiting until debugger is attached
RequestAdditionalTime(1000); // Prevents the service from timeout
Thread.Sleep(1000); // Gives you time to attach the debugger
}
RequestAdditionalTime(20000); // for Debugging the OnStart method,
// increase as needed to prevent timeouts
}
base.OnStart(args);
// put your startup service code here:
_logger.Info("Service is Started.");
ValidateSettings();
// this scheduler was part of the app template.
// not used for now, but could be a nice and easy way to schedule other tasks in the service
// initScheduler();
_replayer = new Replayer();
_replayer.Run(General.Default.ServerName, General.Default.TagQueryString);
}
catch (Exception exception)
{
_logger.Fatal(exception);
}
}
private void OnSelectedEventChanged(object sender, TracefileEventChangedEventArgs e)
{
NotifyOfPropertyChange(() => SelectedEvent);
_objects.Clear();
if (_selectionService.SelectedEvent == null)
{
return;
}
var swapChainPresenter = new WpfSwapChainPresenter(Dispatcher.CurrentDispatcher);
var replayer = new Replayer(
_selectionService.SelectedFrame.Model, _selectionService.SelectedEvent.Model,
swapChainPresenter);
Task.Factory.StartNew(() =>
{
replayer.Replay();
_objects.AddRange(replayer.Device.DeviceChildren
.Select(x => new GraphicsObjectViewModel(x)));
});
}
public static bool GoToMainMenu() => SceneIntermediary.LoadScene(
new SceneIntermediary.SceneRequest(References.mainMenu,
SceneIntermediary.SceneRequest.Reason.ABORT_RETURN, () => {
Instance.Request?.Cancel();
Replayer.Cancel();
}));
void Awake()
{
goCam1 = new GameObject();
goCam1.name = "ReplayCam1";
trCam1 = goCam1.transform;
trCam1.SetParent(this.transform);
cam1 = goCam1.AddComponent <Camera>();
cam1.cullingMask = ~(1 << 5);
_replayer = GameObject.Find("pnlReplayer(Clone)").GetComponent <Replayer>();
Car = _replayer.PlayerCarManager.goCar.transform;
cam1.farClipPlane = 100;
cam1.nearClipPlane = 0.3f;
cam1.useOcclusionCulling = true;
cam1.clearFlags = CameraClearFlags.SolidColor;
cam1.backgroundColor = new Color(0.69f, 0.69f, 0.69f, 1f);
GetPurchasedCameras();
PlayerFrames = (from d
in Recrdng.Current.Data
select d[Recrdng.Current.PlayerCarId]).ToList();
/*
* List<CarStopFrame> CarStopFrames = new List<CarStopFrame>();
* if (PurchasedCameras.Count(c => c.Name == "Stop Cam") > 0)
* {
* //Find where the car changes direction suddenly
* for (int i = 100; i < Recrdng.Current.FrameCount - 150; i++)
* {
* Vector3 velocity = PlayerFrames[i - 14].Pos - PlayerFrames[i - 50].Pos;
* Vector2 velocity2d = new Vector2(velocity.x, velocity.z);
* Vector3 nextVelocity = PlayerFrames[i].Pos - PlayerFrames[i - 1].Pos;
* Vector2 nextVelocity2d = new Vector2(nextVelocity.x, nextVelocity.z);
* //This version works out the the component of nextvel2d that as in the same direction as vel2d
* float angle = Vector2.Angle(nextVelocity2d, velocity2d);
* float relativeSpeed = nextVelocity.magnitude * Mathf.Cos(angle * Mathf.Deg2Rad);
* float velocityDelta = (nextVelocity - velocity).sqrMagnitude;
* //Debug.Log("vel" + velocity.sqrMagnitude.ToString() + " diff" + (nextVelocity - velocity).sqrMagnitude.ToString());
* //if (velocity.sqrMagnitude>nextVelocity.sqrMagnitude && velocityDelta > 0.04f)
* if (velocity2d.sqrMagnitude > 25 && relativeSpeed < 0.03f && nextVelocity.sqrMagnitude < 1)
* {
* CarStopFrame csf = new CarStopFrame();
* csf.Frame = i;
* csf.VelocityDelta = velocityDelta;
* csf.RelativeSpeed = relativeSpeed;
* CarStopFrames.Add(csf);
* }
* }
* }
*
*
* CarStop _carStop = new CarStop(); //start with a dummy carstop
* _carStop.StartFrame = 0;
* _carStop.EndFrame = 0;
* CarStopFrame _smallestRel = new CarStopFrame();
* _smallestRel.RelativeSpeed = 1000;
* //Move through the CarStopFrames and find the one where the velocity changes the most
* foreach (CarStopFrame f in CarStopFrames)
* {
*
* if (f.Frame <= _carStop.EndFrame + 100) // There is no distict gap since the last CarStopFrame
* _carStop.EndFrame = f.Frame; //this keeps getting incremented until there is a gap
* else
* { //there was a gap so finish off last CarStop
* if (_carStop.StartFrame != 0) //if its not the dummy one then finish it off
* {
* AddCarStop(_carStop);
* }
* _carStop = new CarStop();
* _carStop.StartFrame = f.Frame - 100;
* _carStop.EndFrame = f.Frame;
* }
* }
* //Finish off the last CarStop
* if (_carStop.StartFrame > 0)
* {
* AddCarStop(_carStop);
* }
*/
//set the counter ready for when it's running
Init();
}
private static void Main(string[] args)
{
TextWriter writer = Console.Out;
try
{
var options = new CommandLineOptions();
if (Parser.Default.ParseArguments(args, options))
{
if (args.Length <= 1)
{
Console.Write(options.GetUsage());
}
if (options.Run != null && ValidateRunOptions(options.Run))
{
_logger.Info("Option Run starting, will run the data replay continuously as a command line application.");
var replayer = new Replayer();
replayer.RunFromCommandLine(options.Run[0], options.Run[1]);
}
if (options.deleteHistory != null && ValidateDeleteHistoryOptions(options.deleteHistory))
{
_logger.Info("Delete History Option Selected, will deleted the specified data.");
_logger.Info("This operation cannot be reversed, are you sure you want to delete the data you specified? Press Y to continue...");
var keyInfo = Console.ReadKey();
if (keyInfo.KeyChar != 'Y')
{
_logger.Info("Operation canceled");
}
// getting the tags
var piConnection = new PIConnection(options.deleteHistory[0]);
piConnection.Connect();
var pointsProvider = new PIPointsProvider(options.deleteHistory[3], piConnection.GetPiServer());
foreach (var piPoint in pointsProvider.Points)
{
var st = AFTime.Parse(options.deleteHistory[1]);
var et = AFTime.Parse(options.deleteHistory[2]);
_logger.InfoFormat("Deleting history for tag: {0} between {1:G} and {2:G}", piPoint.Name, st.LocalTime, et.LocalTime);
PIHelpers.DeleteValues(piPoint, st, et, options.ForceUpdateValuesMethod);
}
}
}
else
{
options.GetUsage();
}
}
catch (Exception ex)
{
Console.SetOut(writer);
Console.WriteLine("Error: " + ex);
}
}
public CamController_Driver(Transform Cam, Transform Car, Replayer rep)
{
_car = Car;
_trCam = Cam;
_replayer = rep;
}
public static void Main(string[] args)
{
var hello = Hello.Deserialize(new Reader(new byte[] {
// Numbers: 1, 2, 1337
2, 7, 0, 2, 8, 4, 16, 242, 20,
// Others: -1, -2, 1337
10, 4, 1, 3, 242, 20,
}));
Console.WriteLine("Numbers: {0}", String.Join(", ", hello.Numbers));
Console.WriteLine("Others: {0}", String.Join(", ", hello.Others));
Outer.OnUpdateFoo((newValue, oldValue, container) => {
Console.WriteLine("Outer / Foo: {0} => {1}", oldValue, newValue);
});
Outer.OnUpdateBar((newValue, oldValue, container) => {
Console.WriteLine("Outer / Bar: {0} => {1}", oldValue, newValue);
});
Outer.OnUpdateInner((newValue, oldValue, container) => {
Console.WriteLine("Outer / Inner: {0} => {1}", InnerToString(oldValue), InnerToString(newValue));
});
Inner.OnUpdateFoo((newValue, oldValue, container) => {
Console.WriteLine("Outer / Inner / Foo: {0} => {1}", oldValue, newValue);
});
Inner.OnUpdateBar((newValue, oldValue, container) => {
Console.WriteLine("Outer / Inner / Bar: {0} => {1}", oldValue, newValue);
});
var outer = new Outer();
Replayer.Replay(ref outer, new Reader(new byte[] {
8, 0, 2, 1, 0, 10, 2, 254, 1,
7, 0, 2, 1, 1, 10, 1, 1,
10, 0, 2, 1, 2, 10, 4, 0, 44, 8, 1,
9, 0, 2, 2, 2, 0, 10, 2, 192, 2,
4, 0, 2, 1, 2,
1, 0,
}));
Console.WriteLine("{0} {1} {2}", outer.Foo, outer.Bar, InnerToString(outer.Inner));
Multicase.OnUpdate((newValue, newVariant, oldValue, oldVariant, container) => {
Console.WriteLine("Multicase: variant {0} ({1}) => variant {2} ({3}", oldVariant, oldValue, newVariant, newValue);
});
Multicase.FirstCase.OnUpdateFoo((newValue, oldValue, container) => {
Console.WriteLine("Multicase / FirstCase / Foo: {0} => {1}", oldValue, newValue);
});
Multicase.FirstCase.OnUpdateBar((newValue, oldValue, container) => {
Console.WriteLine("Multicase / FirstCase / Bar: {0} => {1}", oldValue, newValue);
});
Multicase.SecondCase.OnUpdateFoo((newValue, oldValue, container) => {
Console.WriteLine("Multicase / SecondCase / Foo: {0} => {1}", oldValue, newValue);
});
Multicase.SecondCase.OnUpdateBar((newValue, oldValue, container) => {
Console.WriteLine("Multicase / SecondCase / Bar: {0} => {1}", oldValue, newValue);
});
var multicase = new Multicase();
Replayer.Replay(ref multicase, new Reader(new byte[] {
4, 0, 10, 1, 1,
9, 0, 2, 2, 1, 0, 10, 2, 136, 1,
}));
var list1 = new StateList <Inner>();
list1.OnUpdate((newItem, oldItem, tag, container) => {
Console.WriteLine("List<Inner>, update #{0}: {1} => {2}", tag, InnerToString(oldItem), InnerToString(newItem));
});
list1.OnAdd((item, tag, container) => {
Console.WriteLine("List<Inner>, add #{0}: {1}", tag, InnerToString(item));
});
list1.OnRemove((item, tag, container) => {
Console.WriteLine("List<Inner>, remove #{0}: {1}", tag, InnerToString(item));
});
Replayer.Replay(ref list1, new Reader(new byte[] {
5, 1, 10, 2, 0, 12,
8, 1, 10, 5, 0, 154, 1, 8, 1,
1, 1,
9, 0, 2, 2, 1, 0, 10, 2, 136, 1,
4, 2, 2, 1, 0,
4, 2, 2, 1, 1,
}));
var list2 = new StateList <SByte>();
list2.OnUpdate((newItem, oldItem, tag, container) => {
Console.WriteLine("List<SByte>, update #{0}: {1} => {2}", tag, oldItem, newItem);
});
list2.OnAdd((item, tag, container) => {
Console.WriteLine("List<SByte>, add #{0}: {1}", tag, item);
});
list2.OnRemove((item, tag, container) => {
Console.WriteLine("List<SByte>, remove #{0}: {1}", tag, item);
});
Replayer.Replay(ref list2, new Reader(new byte[] {
4, 1, 10, 1, 20,
4, 1, 10, 1, 22,
4, 1, 10, 1, 0,
4, 2, 2, 1, 1,
}));
var map1 = new StateDictionary <Inner>();
map1.OnUpdate((newItem, oldItem, tag, container) => {
Console.WriteLine("Dictionary<Inner>, update #{0}: {1} => {2}", tag, InnerToString(oldItem), InnerToString(newItem));
});
map1.OnRemove((item, tag, container) => {
Console.WriteLine("Dictionary<Inner>, remove #{0}: {1}", tag, InnerToString(item));
});
Replayer.Replay(ref map1, new Reader(new byte[] {
8, 0, 2, 1, 5, 10, 2, 0, 12,
11, 0, 2, 1, 1, 10, 5, 0, 154, 1, 8, 1,
4, 0, 2, 1, 0,
9, 0, 2, 2, 1, 0, 10, 2, 136, 1,
4, 2, 2, 1, 0,
}));
var map2 = new StateDictionary <SByte>();
map2.OnUpdate((newItem, oldItem, tag, container) => {
Console.WriteLine("Dictionary<SByte>, update #{0}: {1} => {2}", tag, oldItem, newItem);
});
map2.OnRemove((item, tag, container) => {
Console.WriteLine("Dictionary<SByte>, remove #{0}: {1}", tag, item);
});
Replayer.Replay(ref map2, new Reader(new byte[] {
7, 0, 2, 1, 1, 10, 1, 20,
7, 0, 2, 1, 3, 10, 1, 22,
7, 0, 2, 1, 7, 10, 1, 0,
4, 2, 2, 1, 1,
}));
Action.OnUpdate((newValue, newVariant, oldValue, oldVariant, container) => {
Console.WriteLine("Action: variant {0} ({1}) => variant {2} ({3}", oldVariant, oldValue, newVariant, newValue);
});
Action.Attack.OnUpdateAttacker((newValue, oldValue, container) => {
Console.WriteLine("Action / Attack / Attacker: {0} => {1}", oldValue, newValue);
});
Action.Attack.OnUpdateDefender((newValue, oldValue, container) => {
Console.WriteLine("Action / Attack / Defender: {0} => {1}", oldValue, newValue);
});
Action.Attack.OnUpdateHits((newValue, oldValue, container) => {
Console.WriteLine("Action / Attack / Hits:");
if (oldValue.Count > 0)
{
Console.WriteLine("Old Hits:");
foreach (var hit in oldValue)
{
Console.WriteLine(HitToString(hit));
}
}
else
{
Console.WriteLine("Old Hits:\n<empty>");
}
if (newValue.Count > 0)
{
Console.WriteLine("New Hits:");
foreach (var hit in newValue)
{
Console.WriteLine(HitToString(hit));
}
}
else
{
Console.WriteLine("New Hits:\n<empty>");
}
});
var action = new Action();
Replayer.Replay(ref action, new Reader(new byte[] {
// Set variant from to `Action::Attack`
4, 0, 10, 1, 1,
// Set attacker to 1
8, 0, 2, 2, 1, 0, 10, 1, 1,
// Set defender to 2
8, 0, 2, 2, 1, 1, 10, 1, 2,
// Add 4 hits with dummy values from 6 to 9, inclusive
83, 0, 2, 2, 1, 2, 10, 76,
2, 17, 2, 1, 0, 10, 1, 0, 18, 1, 0, 26, 1, 0, 34, 1, 0, 40, 12,
10, 17, 2, 1, 0, 10, 1, 0, 18, 1, 0, 26, 1, 0, 34, 1, 0, 40, 14,
18, 17, 2, 1, 0, 10, 1, 0, 18, 1, 0, 26, 1, 0, 34, 1, 0, 40, 16,
26, 17, 2, 1, 0, 10, 1, 0, 18, 1, 0, 26, 1, 0, 34, 1, 0, 40, 18,
}));
}
public void RunReplay()
{
state = ReplayHelperState.REPLAYING;
Replayer.BeginReplaying(new Replayer.ReplayerConfig(replayFinishMethod,
SaveData.Replays.LoadReplayFrames(runReplay)));
}
public CamController_Wheelarch(Transform Cam, Transform Car, Replayer rep)
{
_car = Car;
_trCam = Cam;
_replayer = rep;
}
public CamController_Rotating(Transform Cam, Transform Car, Replayer rep)
{
_car = Car;
_trCam = Cam;
_replayer = rep;
}
public CamController_Hedgehog(Transform Cam, Transform Car, Replayer rep)
{
_car = Car;
_trCam = Cam;
_replayer = rep;
}
public static void Main(string[] args)
{
Log.SetLevel(Log.Level.FINE);
BotAppLogic.Beep(settings);
Point offset;
Iterator <Image> screen;
DeviceControl deviceControl;
if (INPUT_MODE == InputMode.WIN32)
{
Console.WriteLine("## win32 mode ##");
deviceControl = new Win32Control();
// wait
Log.Info("waiting ...");
Thread.Sleep(10000);
// full screen
Console.WriteLine("## scanning for table ##");
Image fullScreen = new ScreenImageIterator(deviceControl).next();
offset = PatternLocator.locateTable(fullScreen);
Console.WriteLine("table found at x=" + offset.X + " y=" + offset.Y);
// desk
screen = new ScreenImageIterator(deviceControl, new Rectangle(offset.X, offset.Y, new TableLayout9().Size.Width, new TableLayout9().Size.Height));
screen = new WaitDeltaImageIterator(screen);
}
else if (INPUT_MODE == InputMode.VM)
{
Console.WriteLine("## vm mode ##");
// boot
deviceControl = new VirtualBoxControl(BotAppLogic.ReadConfig()["vm"]);
// poker
Console.WriteLine("waiting for pokerstars ...");
Console.ReadKey();
// mouse
deviceControl.ResetMouse();
// full screen
Console.WriteLine("## scanning for table ##");
Image fullScreen = new ScreenImageIterator(deviceControl).next();
offset = PatternLocator.locateTable(fullScreen);
Console.WriteLine("table found at x=" + offset.X + " y=" + offset.Y);
// desk
screen = new ScreenImageIterator(deviceControl, new Rectangle(offset.X, offset.Y, new TableLayout9().Size.Width, new TableLayout9().Size.Height));
screen = new WaitDeltaImageIterator(screen);
}
else
{
Console.WriteLine("## mock mode ##");
screen = new MockWaitImageIterator(1000, ImageTools.toImage(new Bitmap("test/table_check_free.png")));
offset = new Point(renderer.Control.Location.X + 5, renderer.Control.Location.Y + 15);
deviceControl = new Win32Control();
}
// identifier
TableLayout layout = new TableLayout9(offset);
TableIdentifier tableIdentifier = new TableIdentifier(layout);
tableIdentifier.Renderer = renderer;
// evaluator
List <Rule> rules = RulesReader.readRules();
RuleEvaluator evaluator = new RuleEvaluator(rules);
RuleInterpreter interpreter = new RuleInterpreter(settings.SmallBlind, settings.BigBlind);
// controller
double betSlideTextLimit = settings.PlayMoney ? 100 : 0.2;
Mouse mouse = new HumanMouse(deviceControl);
Keyboard keyboard = new Keyboard(deviceControl);
Controller controller = new Controller(keyboard, mouse, betSlideTextLimit, tableIdentifier, new ScreenImageIterator(deviceControl));
// replayer
Replayer replayer = new Replayer(deviceControl);
// auto-click
RandomClicker clicker = new RandomClicker(new Point(deviceControl.DisplayWidth, 0), mouse);
// initial table
Console.WriteLine("## initial table scan ##");
string player = BotAppLogic.ReadConfig()["name"];
Console.WriteLine("looking for '" + player + "'");
int seat = -1;
/*while (seat == -1)
* {
* Table previousTable = tableIdentifier.identifyTable(screen.next(), TableIdentifier.PlayerInfoEnum.BOTH);
* seat = BotAppLogic.IdentifySeat(previousTable, player);
* Thread.Sleep(1000);
* }
* Console.WriteLine("my seat = " + (seat+1)); */
seat = 4;
// loop
while (screen.hasNext())
{
// start
Console.WriteLine("## iteration -> start ##");
DateTime start = DateTime.Now;
// table
Console.WriteLine("# next table image");
Image tableImage = screen.next();
// render table
renderer.clearImages();
renderer.renderImage(tableImage, 0, 0);
// identify table
//try
//{
if (tableIdentifier.identifyMove(tableImage))
{
Table table = tableIdentifier.identifyTable(tableImage, seat);
List <TableControl> controls = tableIdentifier.identifyControls(tableImage);
table.MaxBet = BotAppLogic.GetMaxBet(controls);
TableContainer container = new TableContainer(0, null, null, layout, seat, false, null);
new BotAppLogic(deviceControl).ProcessTable(settings, tableImage, renderer, table, container, evaluator, interpreter, controller, replayer, clicker, controls);
}
else
{
BotAppLogic.Sleep(settings, 1000);
}
/*}
* catch(Exception ex)
* {
* Console.WriteLine("Unable to identify table");
* Console.WriteLine(ex.ToString());
* Thread.Sleep(5000);
* continue;
* }*/
// end
double time = DateTime.Now.Subtract(start).TotalMilliseconds;
Console.WriteLine("## iteration -> end -> " + time + " ms ##");
}
}
public ReplayerGameObjectController(List <iVehicleManager> rvms, Replayer replayer)
{
Recbles = rvms.Select(vm => new RecordableVehicle(vm));
_replayer = replayer;
}
private void OnSceneLoad()
{
Replayer.LoadLazy();
(new GameObject("Scene-Local CRU")).AddComponent <SceneLocalCRU>();
}
