private void JobRunner()
{
while (true)
{
_enqueueSignal.WaitOne();
while (JobQueue.Count > 0)
{
Job job = null;
lock (_jobQueueLock)
{
if (JobQueue.Count > 0)
{
job = JobQueue.Dequeue();
}
}
if (job != null)
{
job.JobFinished += (o, a) =>
{
Job j = (Job)o;
if (Running.Contains(j))
{
Running.Remove(j);
}
_runCompleteSignal.Set();
};
RunJob(job);
}
}
}
}
public async Task <IActionResult> Edit(int id, [Bind("ID,Date,Distance,Time,RunType")] Running running)
{
if (id != running.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(running);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RunningExists(running.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(running));
}
void Model_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
{
if (e.PropertyName == "TraceStates")
{
switch (Model.TraceStates)
{
case TraceStates.Running:
Running.Begin(cTraceState, true);
Starting.Stop(cTraceState);
Stopping.Stop(cTraceState);
break;
case TraceStates.Starting:
Starting.Begin(cTraceState, true);
Stopping.Stop(cTraceState);
Running.Stop(cTraceState);
break;
case TraceStates.Stopping:
Stopping.Begin(cTraceState, true);
Running.Stop(cTraceState);
Starting.Stop(cTraceState);
break;
case TraceStates.Stopped:
default:
Starting.Stop(cTraceState);
Stopping.Stop(cTraceState);
Running.Stop(cTraceState);
break;
}
}
}
private void Update(EvaluationContext context)
{
if (!_initialized || TriggerReset.GetValue(context))
{
Result.Value = DefaultValue.GetValue(context);
_initialized = true;
}
var triggered = Running.GetValue(context);
if (OnlyCountChanges.GetValue(context) && triggered == _lastTrigger)
{
return;
}
_lastTrigger = triggered;
if (triggered)
{
Result.Value += Increment.GetValue(context);
}
var modulo = Modulo.GetValue(context);
if (modulo != 0)
{
Result.Value %= modulo;
}
}
// prebacujemo onaj proces koji je najvise koristio CPU
public void RunningToReady()
{
int cpu = 0;
Process p = null;
foreach (Process pr in this.Running)
{
if (pr.CPU_usage >= cpu)
{
cpu = pr.CPU_usage;
p = pr;
}
}
if (p == null || Running.Count == 0)
{
//Console.WriteLine("No running process.");
}
else
{
p.Status = "Ready";
Running.Remove(p);
Ready.Add(p);
//Console.WriteLine("RunningTOReady");
}
}
// GET: /Action/Launch
public ActionResult Launch(
string name,
string args,
string title,
string detach)
{
Security.ClearSavedProfile();
if (String.IsNullOrEmpty(Running.RunningProgram))
{
DesktopClient.SendSpecialkey("ClearDesktop");
}
if (!string.IsNullOrEmpty(name))
{
if (!string.IsNullOrEmpty(args))
{
args = HttpUtility.UrlDecode(args);
}
if (!string.IsNullOrEmpty(detach))
{
Running.LaunchNewProgram(name, args);
}
else
{
Running.LaunchProgram(name, args);
}
}
return(Content("OK"));
}
async void doStop(CommandArgs e)
{
if (e.Parameters.Count == 0)
{
e.Player.SendErrorMessage($"Invalid syntax! Proper syntax: {Commands.Specifier}timeline stop <name>");
return;
}
string name = e.Parameters[0];
if (!Running.Exists(t => t.Name.Equals(name, StringComparison.OrdinalIgnoreCase)))
{
e.Player.SendErrorMessage($"'{name}' isn't running.");
}
else
{
if (!e.Player.CanUseTimeline(Path.Combine(TShock.SavePath, name.EndsWith(".txt") ? name : $"{name}.txt")))
{
e.Player.SendErrorMessage("You don't have access to this timeline.");
return;
}
Timeline timeline = Running.Find(t => t.Name.Equals(name, StringComparison.OrdinalIgnoreCase));
e.Player.SendInfoMessage($"Stopping {timeline.Name}...");
await timeline.Stop();
e.Player.SendSuccessMessage($"{timeline.Name} stopped.");
}
}
public virtual async Task Update(Running running)
{
using (var conn = CreateDbConnection())
{
await conn.ExecuteAsync($"UPDATE running SET priority = @Priority,blocktimes =@BlockTimes, lastmodificationtime = {GetDateSql} WHERE {LeftEscapeSql}identity{RightEscapeSql} = @Identity", running);
}
}
// skickar in inputen för typen av sport
// båda int variablerna går igenom en try catch för att kolla så de är int
//en instansiering av klassen görs sen skickar vi in Seconds och Meters till addWorkout för att lägga till en färdig träning
private void chooseTypOfTraining(enumSportMenu Choice2)
{
int inputMeters = GetWorkoutDistance();
int inputSeconds = GetWorkoutTime();
switch (Choice2)
{
case enumSportMenu.Running:
ClassLibrary.Running runningWorkout = new Running();
runningWorkout.AddWorkout(inputMeters, inputSeconds);
break;
case enumSportMenu.Walking:
ClassLibrary.Walking walkingWorkout = new Walking();
walkingWorkout.AddWorkout(inputMeters, inputSeconds);
break;
case enumSportMenu.Biking:
ClassLibrary.Biking bikingWorkout = new Biking();
bikingWorkout.AddWorkout(inputMeters, inputSeconds);
break;
default:
throw new ArgumentOutOfRangeException("Only 1-3");
}
Console.ReadLine();
}
public int CompareTo(Run other)
{
if (ReferenceEquals(this, other))
{
return(0);
}
if (ReferenceEquals(null, other))
{
return(1);
}
var raceIdComparison = RaceId.CompareTo(other.RaceId);
if (raceIdComparison != 0)
{
return(raceIdComparison);
}
var runNoComparison = RunNo.CompareTo(other.RunNo);
if (runNoComparison != 0)
{
return(runNoComparison);
}
var runningComparison = Running.CompareTo(other.Running);
if (runningComparison != 0)
{
return(runningComparison);
}
return(Finished.CompareTo(other.Finished));
}
protected internal void RunJob(Job job, int stepNumber = 0)
{
lock (_runningLock)
{
if (Running.Count >= MaxConcurrentJobs)
{
_runCompleteSignal.WaitOne();
}
job.WorkerException += (o, a) =>
{
OnWorkerException(job.CurrentWorkState);
};
job.WorkerStarting += (o, a) =>
{
OnWorkerStarting(job.CurrentWorkState);
};
job.WorkerFinished += (o, a) =>
{
OnWorkerFinished(job.CurrentWorkState);
};
job.JobFinished += (o, a) =>
{
OnJobFinished(job.CurrentWorkState);
};
Running.Add(job);
}
job.StepNumber = stepNumber;
job.Run();
}
// GET: /Action/GoChromecastAudio
public ActionResult GoChromecastAudio()
{
Running.StartStream("Chromecast");
Receiver.SelectChromecastInput();
Receiver.SelectRoomsOutput();
Screen.SetScreenDisplayMode(0);
return(Content(""));
}
// GET: /Action/GoChromecast
public ActionResult GoChromecast()
{
Screen.EnsureScreenOn();
Running.StartStream("Chromecast");
Receiver.SelectChromecastInput();
Receiver.SelectTVOutput();
return(Content(""));
}
public new string ToString()
{
return(new StringBuilder()
.Append("Work ID : ").Append(m_ID.ToString())
.Append("Running : ").Append(Running.ToString())
.Append("Paused : ").Append(Paused.ToString())
.ToString());
}
public virtual async Task Add(Running history)
{
using (var conn = CreateDbConnection())
{
await conn.ExecuteAsync($"INSERT INTO running ({LeftEscapeSql}identity{RightEscapeSql},priority,blocktimes,creationtime) VALUES (@Identity, @Priority,@BlockTimes,{GetDateSql})", history);
await conn.ExecuteAsync($"INSERT INTO runninghistory ({LeftEscapeSql}identity{RightEscapeSql},priority,creationtime) VALUES (@Identity, @Priority,{GetDateSql})", history);
}
}
// GET: /Action/GoRoku
public ActionResult GoRoku()
{
Roku.KeyPress("Home");
Screen.EnsureScreenOn();
Running.StartStream("Roku");
Receiver.SelectRokuInput();
Receiver.SelectTVOutput();
return(Content(""));
}
// GET: /Action/GoPrime
public ActionResult GoPrime()
{
Screen.EnsureScreenOn();
Running.StartStream("Prime");
Receiver.SelectComputerInput();
Receiver.SelectTVOutput();
DesktopClient.LaunchProgram("Prime", null);
return(Content(""));
}
// GET: /Action/GoSmart
public ActionResult GoSmart()
{
Screen.EnsureScreenOn(false);
Running.StartStream("SmartTv");
Screen.WaitForScreenOn();
Receiver.SelectTvInput();
Receiver.SelectTVOutput();
Samsung.SendKey("CONTENTS");
return(Content(""));
}
static public void Restore()
{//复原
isGo = 0;
cmdList.Clear();
NextP.Clear();
SetAnimatorIdle();
isStop = true;
Running.liftBanBt();
index = 0;
}
// Start is called before the first frame update
void Start()
{
stateMachine = new StateMachine();
standing = new Standing(stateMachine);
running = new Running(stateMachine);
ducking = new Ducking(stateMachine);
jumping = new Jumping(stateMachine);
walking = new Walking(stateMachine);
stateMachine.HandleInput();
}
public async Task <IActionResult> Create([Bind("ID,Date,Distance,Time,RunType")] Running running)
{
if (ModelState.IsValid)
{
_context.Add(running);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(running));
}
// GET: /Action/GoLogFire
public ActionResult GoLogFire()
{
Screen.EnsureScreenOn();
if (Running.RunningProgram != "Music" && Running.RunningProgram != "Spotify")
{
Running.StartStream("LogFire");
}
Receiver.SelectComputerInput();
DesktopClient.LaunchProgram("LogFire", null);
return(Content(""));
}
// Token: 0x060014B6 RID: 5302 RVA: 0x0002318C File Offset: 0x0002218C
protected override WorkflowElement CreateBody()
{
StateGraph stateGraph = new StateGraph("BasicPursuitFlow");
State state = new State("running");
State state2 = new State("done");
EnableLoadingScreen item = new EnableLoadingScreen(true);
RelaySync item2 = new RelaySync(0.1f);
LoadBlackBoards item3 = new LoadBlackBoards(base.InstancedEvent, BlackBoardFlag.kBlackBoardFlag_Running);
BeginEventSecurity item4 = new BeginEventSecurity();
FlushCops item5 = new FlushCops();
PrimeCopVehicleCache item6 = new PrimeCopVehicleCache(base.InstancedEvent, Hash.Hash32("copsuv"), 12);
PrimeCopVehicleCache item7 = new PrimeCopVehicleCache(base.InstancedEvent, Hash.Hash32("copcarmus08gh"), 4);
SpawnCops item8 = new SpawnCops(base.InstancedEvent);
AddOpponents item9 = new AddOpponents(base.InstancedEvent);
WaitForOpponentsReady item10 = new WaitForOpponentsReady(base.InstancedEvent, 0.1f);
PrepareGrid item11 = new PrepareGrid(base.InstancedEvent);
CommitAllAssets item12 = new CommitAllAssets();
PlaceAtLocators item13 = new PlaceAtLocators(base.InstancedEvent);
EnableHud item14 = new EnableHud(base.InstancedEvent, EnableHud.HudToggle.Enable);
GameCore.Activities.Event.Components.AssignPowerupConfiguration item15 = new GameCore.Activities.Event.Components.AssignPowerupConfiguration(base.InstancedEvent);
Running <EntrantPursuit> activity = new Running <EntrantPursuit>(base.InstancedEvent, new string[]
{
"Entrants.Loading"
});
PerfectLaunchAchieved activity2 = new PerfectLaunchAchieved(base.InstancedEvent, Ports.Gameplay);
CleanupEvent item16 = new CleanupEvent(base.InstancedEvent);
CleanupGrid item17 = new CleanupGrid(base.InstancedEvent);
state.EnterActivity.Activities.Add(item);
state.EnterActivity.Activities.Add(item3);
state.EnterActivity.Activities.Add(item4);
state.EnterActivity.Activities.Add(item5);
state.EnterActivity.Activities.Add(item6);
state.EnterActivity.Activities.Add(item7);
state.EnterActivity.Activities.Add(item2);
state.EnterActivity.Activities.Add(item8);
state.EnterActivity.Activities.Add(item9);
state.EnterActivity.Activities.Add(item10);
state.EnterActivity.Activities.Add(item11);
state.EnterActivity.Activities.Add(item12);
state.EnterActivity.Activities.Add(item13);
state.EnterActivity.Activities.Add(item14);
state.EnterActivity.Activities.Add(item15);
state.Transitions.Add(new Transition(activity2));
state.Transitions.Add(new Transition("done", activity));
state2.EnterActivity.Activities.Add(item16);
state2.EnterActivity.Activities.Add(item17);
stateGraph.InitialState = "running";
stateGraph.DoneState = "done";
stateGraph.States.Add(state);
stateGraph.States.Add(state2);
return(stateGraph);
}
public void click()
{
Invoker.Restore();
Running.initRobot();
tools.init();
isRecovery = GameObject.Find("Recovery");
if (isRecovery != null)
{
isRecovery.transform.tag = "isRecovery_Y";
Debug.Log(isRecovery.transform.tag);
}
}
private void ProcessFinish(object sender, System.Timers.ElapsedEventArgs e)
{
foreach (Process p in Running)
{
if (p.CPU_usage == 100)
{
p.Finish();
Running.Remove(p);
break;
}
}
}
public async Task <string> SendCommandAsync(string[] arguments, CancellationToken cancel)
{
try
{
Running?.Invoke(this, arguments.Where(a => commands.Contains(a.ToLowerInvariant().Trim())).FirstOrDefault() ?? string.Empty);
return(await _inner.SendCommandAsync(arguments, cancel));
}
finally
{
StoppedRunning?.Invoke(this, new EventArgs());
}
}
// GET: /Web/PlayBBC
public ContentResult PlayBBC(
string pid)
{
if (String.IsNullOrEmpty(Running.RunningProgram))
{
DesktopClient.SendSpecialkey("ClearDesktop");
}
Running.LaunchProgram("Web", "-k -nomerge " + BBC.GetTvPlayerUrl(pid));
return(Content("OK"));
}
// GET: /Action/StartSky
public ActionResult StartSky(
string mode)
{
bool isAlreadyRunningSky = Running.RunningProgram == "Sky";
if (mode != "radio")
{
Screen.EnsureScreenOn();
}
else if (!isAlreadyRunningSky)
{
Screen.SetScreenDisplayMode(0);
}
Running.StartSky();
Receiver.SelectSkyInput();
if (mode == "radio")
{
Receiver.SelectRoomsOutput();
}
else
{
Receiver.SelectTVOutput(null, false);
}
if (!isAlreadyRunningSky)
{
Receiver.SetMute(true);
}
DesktopClient.SendIR(IRCodes.Codes["Sky.Watch"], "Sky.Watch");
if (!isAlreadyRunningSky)
{
System.Threading.Thread.Sleep(2000);
SkyData.Sky.ChangeChannel(0);
}
switch (mode)
{
case "planner":
return(Content("/Sky/Recordings"));
case "live":
return(Content("/Sky/Live"));
case "radio":
return(Content("/Sky/Radio"));
}
return(Content("/Sky/Watch"));
}
// GET: /Video/DeleteRecording
public ContentResult DeleteRecording(
string id)
{
// Can't delete a recording that's still playing
Running.StopZoom();
if (DvbViewer.AllRecordings.ContainsKey(id))
{
var recording = DvbViewer.AllRecordings[id];
DvbViewer.DeleteRecording(recording);
}
return(this.Content(""));
}
void doShow(CommandArgs e)
{
string running = String.Join(", ", Running.Select(t => t.Name));
if (String.IsNullOrEmpty(running))
{
e.Player.SendInfoMessage("No timelines are currently running.");
}
else
{
e.Player.SendInfoMessage($"Currently running timelines: {running}.");
}
}
private void timer_tick(object sender, EventArgs e)
{
if (Runs == Running.On)
HeartBeat++;
else
HeartBeat = 0;
if(HeartBeat >= 5)
{
try
{
Runs = Running.Off;
foreach (D2Profile pro in bpro)
{
Process.GetProcessById(pro.D2Process.Id).Kill();
}
}
catch {}
}
ShowHideDebug();
}
public bool StartDiablo()
{
using (var reg = Registry.CurrentUser.OpenSubKey(@"SOFTWARE\D2NG", true))
{
if (reg.GetValue("Diablo 2 Path").ToString() != "")
{
if (Settings[2] == "True")
setD2Screen(3);
else
setD2Screen(4);
if (Settings[0] == "True")
reg.SetValue("Diablo 2 Account", Account);
if (Settings[1] == "True")
reg.SetValue("Diablo 2 Password", Password);
if (SetProfile)
if (SetProfile)
{
bpro.Clear();
bpro.Add(d2profile);
foreach (D2Profile pro in bpro)
{
D2Bot.Program.LaunchClient(pro);
Runs = Running.On;
}
return true;
}
else
return false;
}
else
{
System.Windows.Forms.MessageBox.Show("Select Game.exe in settings!");
}
}
return false;
}
public ResponseHeartbeat()
{
gameObject = GameObject.Find("Running");
running = gameObject.GetComponent<Running>();
}
public ResponseGameState()
{
gameObject = GameObject.Find("GameLogic");
//Debug.Log(gameObject.name);
running = gameObject.GetComponent<Running>();
}
