예제 #1
0
        private void RunCode_EndRun(bool error)
        {
            IChrono runCodeChrono;

            if (_runCode != null)
            {
                //_runCodeChrono = _runCode.RunChrono;
                runCodeChrono = _runCode.RunChrono;
                _runCode      = null;
            }
            else
            {
                //_runCodeChrono = new Chrono();
                runCodeChrono = new Chrono();
            }
            _executionPaused  = false;
            _executionAborted = false;
            //if (EndRun != null)
            //    EndRun(error);
            if (_endRunCode != null)
            {
                _endRunCode(new EndRunCodeInfo {
                    Error = error, RunCodeChrono = runCodeChrono
                });
            }
        }
예제 #2
0
        //private void RunCode_EndRun(bool error)
        private void RunCode_EndRun(RunCode runCode, bool error)
        {
            IChrono runCodeChrono;

            if (runCode != null)
            {
                runCodeChrono = runCode.RunChrono;
                //runCode = null;
            }
            else
            {
                runCodeChrono = new Chrono();
            }
            _executionPaused  = false;
            _executionAborted = false;

            RunCode runCode2;
            bool    errRemoveRunCode = false;

            if (runCode != null)
            {
                errRemoveRunCode = !_runCodes.TryRemove(runCode.Id, out runCode2);
            }
            //Trace.WriteLine("RunCode_EndRun : runCode.Id {0} errRemoveRunCode {1}", runCode.Id, errRemoveRunCode);

            _endRunCode?.Invoke(new EndRunCodeInfo {
                Error = error, RunCodeChrono = runCodeChrono
            });
            if (errRemoveRunCode)
            {
                throw new PBException("unable to remove RunCode id {0} from ConcurrentDictionary", runCode.Id);
            }
        }
예제 #3
0
    // Use this for initialization
    void Start()
    {
        try {
            car = PickerSceneController.selectedCar;
            cam = car.transform.Find("Camera").gameObject;
            cc  = car.GetComponent <CarController>();
            sm  = car.GetComponent <SoundManager>();

            if (cc != null)
            {
                cc.enabled = true;
            }
            if (sm != null)
            {
                sm.enabled = true;
            }
            if (cam != null)
            {
                cam.SetActive(true);
            }
        }
        catch (NullReferenceException) {
            Debug.Log("Missing Component");
            return; //If the scene is played from the editor without car
        }

        if (car != null)
        {
            setCar();
        }

        setBestTime(0, 0);
        chronometer = new Chrono();
        startLap();
    }
예제 #4
0
        public static bool CompileProjects(string projectsFile, Win32ResourceCompiler win32ResourceCompiler, ResourceCompiler resourceCompiler = null, string runsourceSourceDirectory = null, Action<IProjectCompiler> onCompiled = null)
        {
            Chrono chrono = new Chrono();
            chrono.Start();
            int nbProject = 0;
            try
            {
                if (!zFile.Exists(projectsFile))
                    throw new PBException("projects file dont exists \"{0}\"", projectsFile);
                XmlConfig projects = new XmlConfig(projectsFile);
                string projectsDirectory = zPath.GetDirectoryName(projectsFile);
                //string updateDir = _config.GetExplicit("UpdateRunSource/UpdateDirectory").zRootPath(zapp.GetEntryAssemblyDirectory());

                string updateDirectory = projects.Get("UpdateDirectory");

                foreach (XElement project in projects.GetElements("Project"))
                {
                    string projectFile = project.zExplicitAttribValue("value").zRootPath(projectsDirectory);
                    Trace.WriteLine("Compile project \"{0}\"", projectFile);

                    ProjectCompiler compiler = ProjectCompiler.Create(projectFile, win32ResourceCompiler, resourceCompiler);
                    compiler.RunsourceSourceDirectory = runsourceSourceDirectory;
                    compiler.Compile();

                    //if (onCompiled != null)
                    //    onCompiled(compiler);
                    onCompiled?.Invoke(compiler);
                    if (!compiler.Success)
                        return false;
                    string copyOutput = project.zAttribValue("copyOutput").zRootPath(zapp.GetEntryAssemblyDirectory());
                    if (copyOutput != null)
                    {
                        //Trace.WriteLine("  copy result files to directory \"{0}\"", copyOutput);
                        compiler.CopyResultFilesToDirectory(copyOutput);
                    }
                    if (project.zAttribValue("copyToUpdateDirectory").zTryParseAs(false))
                    {
                        if (updateDirectory == null)
                            throw new PBException("update directory is not defined");
                        //Trace.WriteLine("  copy result files to directory \"{0}\"", updateDirectory);
                        compiler.CopyResultFilesToDirectory(updateDirectory);
                    }
                    nbProject++;
                }
            }
            catch (ProjectCompilerException ex)
            {
                Error.WriteMessage(ErrorOptions.TraceError, ex.Message);
            }
            finally
            {
                chrono.Stop();
                Trace.WriteLine("{0} project(s) compiled", nbProject);
                Trace.WriteLine("Process completed {0}", chrono.TotalTimeString);
            }
            return true;
        }
예제 #5
0
 void Start()
 {
     Player1         = GameObject.FindWithTag("Player1").GetComponent <Player>();
     Player2         = GameObject.FindWithTag("Player2").GetComponent <Player>();
     cycle           = GameObject.FindWithTag("cycle").GetComponent <Cycle>();
     chrono          = GameObject.FindWithTag("chrono").GetComponent <Chrono>();
     panelQuitActive = false;
     conf            = GameObject.FindWithTag("configuration").GetComponent <GameConfiguration>();
 }
예제 #6
0
 /// <summary>
 /// Supprimer un chronomètre et sa liste de temps associées
 /// </summary>
 /// <param name="chrono">le chronomètre à supprimer</param>
 public async Task SupChrono(Chrono chrono)
 {
     if (chrono == null)
     {
         return;
     }
     ListTimer.Supprimer(chrono);
     await ListTimer.SaveFile();
 }
예제 #7
0
 /// <summary>
 /// valide ou non un chronomètre
 /// </summary>
 /// <param name="chrono">le chronomètre dont l"état doit changer</param>
 public async Task ValidChrono(Chrono chrono)
 {
     if (chrono == null)
     {
         return;
     }
     chrono.ChangerEtatValidation();
     GetColorEtatChrono(chrono);
     await ListTimer.SaveFile();
 }
예제 #8
0
        /// <summary>
        /// Ajoute un chronomètre
        /// </summary>
        public async Task AddChrono()
        {
            var chrono = new Chrono {
                Id = 0
            };

            ListTimer.AjouterModifier(chrono);
            GetColorEtatChrono(chrono);
            await ListTimer.SaveFile();
        }
예제 #9
0
        private void RunCode_v1(string code, bool useNewThread = true, bool compileWithoutProject = false)
        {
            if (code == "")
                return;

            bool bError = false;
            if (_runCodeThread != null)
                throw new PBException("error program already running");

            bool bOk = false;
            _runCodeChrono = new Chrono();
            try
            {
                AssemblyResolve.Stop();
                AssemblyResolve.Clear();

                _refreshRunSourceConfig = true;
                _refreshProjectConfig = true;

                IGenerateAndExecute generateAndExecute = GetGenerateAndExecuteManager().New();
                _GenerateCodeAndCompile_v2(generateAndExecute, code, compileWithoutProject);
                if (generateAndExecute.Compiler.HasError())
                    return;

                MethodInfo runMethod = generateAndExecute.GetAssemblyRunMethod();
                MethodInfo initMethod = generateAndExecute.GetAssemblyInitMethod();
                MethodInfo endMethod = generateAndExecute.GetAssemblyEndMethod();

                AssemblyResolve.Start();
                if (useNewThread)
                {
                    _runCodeThread = new Thread(new ThreadStart(() => _Run(runMethod, initMethod, endMethod)));
                    _runCodeThread.CurrentCulture = FormatInfo.CurrentFormat.CurrentCulture;
                    _runCodeThread.SetApartmentState(ApartmentState.STA);
                    _runCodeThread.Start();
                }
                else
                {
                    Trace.WriteLine("execute on main thread");
                    _Run(runMethod, initMethod, endMethod);
                }

                bOk = true;
            }
            catch
            {
                bError = true;
                throw;
            }
            finally
            {
                if (!bOk && EndRun != null)
                    EndRun(bError);
            }
        }
    /// <summary>
    /// Update kinect data in multithread
    /// </summary>
    private void UpdateKinectData()
    {
        bool _done = false;

        Chrono chrono = new Chrono();

        chrono.Start();

        double dt = 0.033;

        double next_schedule = 0.0;

        Debug.Log("Kinect acquisition started");

        while (!_done)
        {
            double current_time = chrono.GetElapsedTime();

            if (current_time > next_schedule)
            {
                next_schedule += dt;

                // Get depth map
                UpdateDepthData();

                // Get color map
                UpdateColorData();

                // Convert depth map into point cloud
                _cameraSpace = new CameraSpacePoint[_depthData.Length];

                lock (_cameraSpace)
                {
                    _mapper.MapDepthFrameToCameraSpace(_depthData, _cameraSpace);
                }

                // Map depth map to color map
                _colorSpace = new ColorSpacePoint[_depthData.Length];

                lock (_colorSpace)
                {
                    _mapper.MapDepthFrameToColorSpace(_depthData, _colorSpace);
                }
            }

            lock (doneLock)
            {
                _done = done;
            }

            Thread.Sleep(0);
        }

        Debug.Log("Kinect acquisition stopped");
    }
예제 #11
0
        /// <summary>
        /// Modifie le titre d'un chrono et de tous ses sous chronos
        /// </summary>
        /// <param name="chrono">le chrono dont le titre est à modifier</param>
        public async Task ChangerNomChrono(Chrono chrono)
        {
            if (chrono == null)
            {
                return;
            }
            ListTimer.ModifierTitreChrono(chrono, chrono.TitreTmp);
            await ListTimer.SaveFile();

            chrono.ModifTitreVisible = false;
        }
예제 #12
0
        /// <summary>
        /// Ajout d'un temps à la liste
        /// </summary>
        /// <param name="chrono">le chronomètre à copier</param>
        public async Task SaveChrono(Chrono chrono)
        {
            if (ListTimer.ListeChronos.Count <= 0)
            {
                return;
            }
            var ch = new Chrono(chrono);

            ListTimer.AjouterModifier(ch);
            GetColorEtatChrono(ch);
            await ListTimer.SaveFile();
        }
예제 #13
0
        private void CompileRunSource()
        {
            Chrono chrono = new Chrono();

            chrono.Start();
            int nbProject = 0;

            try
            {
                string updateDir = _config.GetExplicit("UpdateRunSource/UpdateDirectory").zRootPath(zapp.GetEntryAssemblyDirectory());
                Dictionary <string, List <string> > projectFiles = new Dictionary <string, List <string> >();

                foreach (XElement project in _config.GetElements("UpdateRunSource/Project"))
                {
                    ICompiler compiler = CompileProject(project.zExplicitAttribValue("value"));
                    if (compiler.HasError())
                    {
                        return;
                    }
                    string copyOutput = project.zAttribValue("copyOutput").zRootPath(zapp.GetEntryAssemblyDirectory());
                    if (copyOutput != null)
                    {
                        //_trace.WriteLine("  copy result files to directory \"{0}\"", copyOutput);
                        compiler.CopyResultFilesToDirectory(copyOutput);
                    }
                    //_trace.WriteLine("  copy result files to directory \"{0}\"", updateDir);
                    compiler.CopyResultFilesToDirectory(updateDir);
                    nbProject++;
                }

                foreach (XElement project in _config.GetElements("UpdateRunSource/ProjectRunSourceLaunch"))
                {
                    ICompiler compiler = CompileProject(project.zExplicitAttribValue("value"));
                    if (compiler.HasError())
                    {
                        return;
                    }
                    string copyOutput = project.zAttribValue("copyOutput").zRootPath(zapp.GetEntryAssemblyDirectory());
                    if (copyOutput != null)
                    {
                        //_trace.WriteLine("  copy result files to directory \"{0}\"", copyOutput);
                        compiler.CopyResultFilesToDirectory(copyOutput);
                    }
                    nbProject++;
                }
            }
            finally
            {
                chrono.Stop();
                _trace.WriteLine("{0} project(s) compiled", nbProject);
                _trace.WriteLine("Process completed {0}", chrono.TotalTimeString);
            }
        }
예제 #14
0
        /// <summary>
        /// Remet à zéro un chronomètre
        /// </summary>
        /// <param name="chrono"></param>
        /// <returns></returns>
        public async Task ResetChronoTime(Chrono chrono)
        {
            await PauseChrono(chrono);

            var liste = ListTimer.ListeChronos.Where(x => x.IdChrono == chrono.IdChrono && x.IsParent == false).ToList();

            foreach (var ch in liste)
            {
                ListTimer.ListeChronos.Remove(ch);
            }
            chrono.ResetTime();
            await ListTimer.SaveFile();
        }
예제 #15
0
        public CoucheLLC(Signal signal)
        {
            this.m_signal = signal;

            this.m_MACStreamIn  = new BlockingCollection <Trame>();
            this.m_MACStreamOut = new BlockingCollection <Trame>();

            this.m_eventStream     = new BlockingCollection <TypeEvenement>();
            this.m_reseauStreamIn  = new BlockingCollection <Paquet>();
            this.m_reseauStreamOut = new BlockingCollection <Paquet>();

            this.m_chrono   = new Chrono(m_eventStream);
            this.m_ackTimer = new ACKTimer(m_eventStream);
        }
예제 #16
0
        public static void Go()
        {
            Chrono.Start("Batch procedure");

            for (int i = 0; i < 10; i++)
            {
                Chrono.Start("Batch procedure;Cycle");
                Thread.Sleep(100);
                for (int j = 0; j < 10; j++)
                {
                    Chrono.Start("Batch procedure;Cycle;Inner Cycle");

                    Thread.Sleep(10);

                    Chrono.Start("Batch procedure;Cycle;Inner Cycle;Step 1");
                    Thread.Sleep(10);
                    Chrono.Stop("Batch procedure;Cycle;Inner Cycle;Step 1");

                    Chrono.Start("Batch procedure;Cycle;Inner Cycle;Step 2");
                    Thread.Sleep(11);
                    Chrono.Stop("Batch procedure;Cycle;Inner Cycle;Step 2");

                    Chrono.Start("Batch procedure;Cycle;Inner Cycle;Step 3");
                    Thread.Sleep(12);
                    Chrono.Stop("Batch procedure;Cycle;Inner Cycle;Step 3");

                    Chrono.Stop("Batch procedure;Cycle;Inner Cycle");
                }
                Chrono.Stop("Batch procedure;Cycle");
            }

            for (int i = 0; i < 10; i++)
            {
                Chrono.Start("Batch procedure;Cycle2");
                Thread.Sleep(100);
                for (int j = 0; j < 10; j++)
                {
                    Chrono.Start("Batch procedure;Cycle2;Inner Cycle");
                    Thread.Sleep(10);
                    Chrono.Stop("Batch procedure;Cycle2;Inner Cycle");
                }
                Chrono.Stop("Batch procedure;Cycle2");
            }

            Chrono.Stop("Batch procedure");

            Chrono.ShowResults();
        }
예제 #17
0
        public async Task <bool> TestGetUniqueTimestamp64(int numberOfTimestamps)
        {
            IEnumerable <long> GetUniqueTimestamps64()
            {
                return(Enumerable.Range(1, numberOfTimestamps)
                       .Select(_ => Chrono.GetUniqueTimestamp64())
                       .ToList());
            }

            var result = await Task.WhenAll(
                Task.Run(GetUniqueTimestamps64),
                Task.Run(GetUniqueTimestamps64),
                Task.Run(GetUniqueTimestamps64));

            return(result.GroupBy(item => item).All(group => group.Count() == 1));
        }
예제 #18
0
        /// <summary>
        /// Creates a new network frame.
        /// </summary>
        /// <param name="systemName">System name.</param>
        /// <param name="streamName">Stream name.</param>
        /// <param name="totalFramesReceived">Total number of frames received by the media stream so far.</param>
        /// <param name="mediaFrame">Media frame.</param>
        /// <param name="metadataRequired">Indicates whether to include metadata.</param>
        /// <returns>A new network frame.</returns>
        private static NetworkFrame CreateNetworkFrame(string systemName, string streamName, int totalFramesReceived,
                                                       RawFrame mediaFrame, bool metadataRequired)
        {
            byte interpretation = mediaFrame switch
            {
                RawAudioFrame _ => 1,
                RawVideoFrame _ => 2,
                 _ => 0
            };

            return(new NetworkFrame(
                       (ulong)Chrono.GetUniqueTimestamp64(),
                       (uint)totalFramesReceived,
                       interpretation,
                       systemName,
                       streamName,
                       CreateDataSegments(mediaFrame, metadataRequired)));
        }
예제 #19
0
 private void Start()
 {
     su            = GameObject.FindObjectOfType <ScoreUpdate>();
     waveCountdown = timeFirstWave;
     m_chrono      = GameObject.FindGameObjectWithTag("WaveChrono").GetComponent <Chrono>();
     if (m_chrono == null)
     {
         Debug.LogError("Could not find any Chrono object with tag \"Chrono\" in script WaveSpawner.cs");
     }
     m_waveCounter = GameObject.FindGameObjectWithTag("WaveCounter").GetComponent <WaveCounter>();
     if (m_waveCounter == null)
     {
         Debug.LogError("Could not find any WaveCounter object with tag \"WaveCounter\" in script WaveSpawner.cs");
     }
     if (spawnPoints.Length == 0)
     {
         Debug.LogError("Pas de points de spawn");
     }
 }
예제 #20
0
파일: RunCode.cs 프로젝트: labeuze/source
        public void Run(bool runOnMainThread)
        {
            _runChrono = new Chrono();
            if (_runAssembly == null)
                throw new PBException("assembly is null");
            MethodInfo runMethod = GetRunMethod();

            //AssemblyResolve.Clear();

            if (!runOnMainThread)
            {
                _runThread = new Thread(new ThreadStart(() => _Run(runMethod)));
                _runThread.CurrentCulture = FormatInfo.CurrentFormat.CurrentCulture;
                _runThread.SetApartmentState(ApartmentState.STA);
                _runThread.Start();
            }
            else
            {
                _Run(runMethod);
            }
        }
예제 #21
0
        public async Task Run_v2(bool runOnMainThread)
        {
            _runChrono = new Chrono();
            if (_runAssembly == null)
            {
                throw new PBException("assembly is null");
            }
            MethodInfo runMethod = GetRunMethod();

            if (!runOnMainThread)
            {
                _runThread = new Thread(new ThreadStart(async() => await _Run_v2(runMethod)));
                _runThread.CurrentCulture = FormatInfo.CurrentFormat.CurrentCulture;
                _runThread.SetApartmentState(ApartmentState.STA);
                _runThread.Start();
            }
            else
            {
                await _Run_v2(runMethod);
            }
        }
예제 #22
0
 public MyTimer(uint ID, Chrono parent)
 {
     this.ID     = ID;
     this.Parent = parent;
 }
예제 #23
0
        public static bool CompileProjects(string projectsFile, Win32ResourceCompiler win32ResourceCompiler, ResourceCompiler resourceCompiler = null, string runsourceSourceDirectory = null, Action <IProjectCompiler> onCompiled = null)
        {
            Chrono chrono = new Chrono();

            chrono.Start();
            int nbProject = 0;

            try
            {
                if (!zFile.Exists(projectsFile))
                {
                    throw new PBException("projects file dont exists \"{0}\"", projectsFile);
                }
                XmlConfig projects          = new XmlConfig(projectsFile);
                string    projectsDirectory = zPath.GetDirectoryName(projectsFile);
                //string updateDir = _config.GetExplicit("UpdateRunSource/UpdateDirectory").zRootPath(zapp.GetEntryAssemblyDirectory());

                string updateDirectory = projects.Get("UpdateDirectory");

                foreach (XElement project in projects.GetElements("Project"))
                {
                    string projectFile = project.zExplicitAttribValue("value").zRootPath(projectsDirectory);
                    Trace.WriteLine("Compile project \"{0}\"", projectFile);

                    ProjectCompiler compiler = ProjectCompiler.Create(projectFile, win32ResourceCompiler, resourceCompiler);
                    compiler.RunsourceSourceDirectory = runsourceSourceDirectory;
                    compiler.Compile();
                    compiler.TraceMessages();

                    //if (onCompiled != null)
                    //    onCompiled(compiler);
                    onCompiled?.Invoke(compiler);
                    if (!compiler.Success)
                    {
                        return(false);
                    }
                    string copyOutput = project.zAttribValue("copyOutput").zRootPath(zapp.GetEntryAssemblyDirectory());
                    if (copyOutput != null)
                    {
                        //Trace.WriteLine("  copy result files to directory \"{0}\"", copyOutput);
                        compiler.CopyResultFilesToDirectory(copyOutput);
                    }
                    if (project.zAttribValue("copyToUpdateDirectory").zTryParseAs(false))
                    {
                        if (updateDirectory == null)
                        {
                            throw new PBException("update directory is not defined");
                        }
                        //Trace.WriteLine("  copy result files to directory \"{0}\"", updateDirectory);
                        compiler.CopyResultFilesToDirectory(updateDirectory);
                    }
                    nbProject++;
                }
            }
            catch (ProjectCompilerException ex)
            {
                Error.WriteMessage(ErrorOptions.TraceError, ex.Message);
            }
            finally
            {
                chrono.Stop();
                Trace.WriteLine("{0} project(s) compiled", nbProject);
                Trace.WriteLine("Process completed {0}", chrono.TotalTimeString);
            }
            return(true);
        }
예제 #24
0
 /// <summary>
 /// Mise en pause du chronomètre
 /// </summary>
 /// <param name="chrono">le chronomètre dont l"état doit changer</param>
 public async Task PauseChrono(Chrono chrono)
 {
     chrono.Stop();
     GetColorEtatChrono(chrono);
     await ListTimer.SaveFile();
 }
예제 #25
0
 void Awake()
 {
     Chrono_instance = this;
 }
예제 #26
0
 void Awake()
 {
     Chrono_instance = this;
 }
예제 #27
0
 public Cycle()
 {
     phases = new Phase[] { new PhaseObject(), new PhaseFight() };
     timer  = Time.deltaTime;
     chrono = new Chrono();
 }
    private void UpdateKinectData()
    {
        bool _done = false;

        Capture _capture = null;
        Chrono  chrono   = new Chrono();

        chrono.Start();

        double dt;

        switch (kinectSensor.cameraFPS)
        {
        case FrameRate.Fifteen:
            dt = 1 / 15;
            break;

        case FrameRate.Thirty:
            dt = 1 / 30;
            break;

        case FrameRate.Five:
            dt = 1 / 5;
            break;

        default:
            dt = 1 / 60;     // default unity fps
            break;
        }
        double next_schedule = 0.0;

        while (!_done)
        {
            double current_time = chrono.GetElapsedTime();

            if (current_time > next_schedule)
            {
                next_schedule += dt;

                lock (capture)
                {
                    if (isCaptureDirty)
                    {
                        _capture       = capture;
                        isCaptureDirty = false;
                    }
                }
                if (_capture != null)
                {
                    UpdateDepthData(_capture);
                    UpdateColorData(_capture);
                    _capture = null;
                }
            }

            lock (doneLock)
            {
                _done = done;
            }

            Thread.Sleep(0);
        }
    }
예제 #29
0
        //private void RunCode_EndRun(bool error)
        private void RunCode_EndRun(RunCode runCode, bool error)
        {
            IChrono runCodeChrono;
            if (runCode != null)
            {
                runCodeChrono = runCode.RunChrono;
                //runCode = null;
            }
            else
            {
                runCodeChrono = new Chrono();
            }
            _executionPaused = false;
            _executionAborted = false;

            RunCode runCode2;
            bool errRemoveRunCode = false;
            if (runCode != null)
                errRemoveRunCode = !_runCodes.TryRemove(runCode.Id, out runCode2);
            //Trace.WriteLine("RunCode_EndRun : runCode.Id {0} errRemoveRunCode {1}", runCode.Id, errRemoveRunCode);

            _endRunCode?.Invoke(new EndRunCodeInfo { Error = error, RunCodeChrono = runCodeChrono });
            if (errRemoveRunCode)
                throw new PBException("unable to remove RunCode id {0} from ConcurrentDictionary", runCode.Id);
        }
예제 #30
0
 /// <summary>
 ///Modifie la vue pour afficher la partie de modification du titre du chrono
 /// </summary>
 /// <param name="chrono">le chrono dont le titre est à modifier</param>
 public void OpenChangerNomChrono(Chrono chrono)
 {
     chrono.ModifTitreVisible = true;
 }
예제 #31
0
 /// <summary>
 /// Démarrage du chronomètre
 /// </summary>
 public async Task StartChrono(Chrono chrono)
 {
     chrono.Start();
     GetColorEtatChrono(chrono);
     await ListTimer.SaveFile();
 }
예제 #32
0
 private void RunCode_EndRun(bool error)
 {
     IChrono runCodeChrono;
     if (_runCode != null)
     {
         //_runCodeChrono = _runCode.RunChrono;
         runCodeChrono = _runCode.RunChrono;
         _runCode = null;
     }
     else
     {
         //_runCodeChrono = new Chrono();
         runCodeChrono = new Chrono();
     }
     _executionPaused = false;
     _executionAborted = false;
     //if (EndRun != null)
     //    EndRun(error);
     if (_endRunCode != null)
         _endRunCode(new EndRunCodeInfo { Error = error, RunCodeChrono = runCodeChrono });
 }
예제 #33
0
 void Start()
 {
     cube = Cube.cube_instance;
     core = Core.instance;
     ev = Event.EvInstance;
     chrono = Chrono.Chrono_instance;
     time = null;
     player_win_timer = null;
 }
예제 #34
0
        private void RunCode_v1(string code, bool useNewThread = true, bool compileWithoutProject = false)
        {
            if (code == "")
            {
                return;
            }

            bool bError = false;

            if (_runCodeThread != null)
            {
                throw new PBException("error program already running");
            }

            bool bOk = false;

            _runCodeChrono = new Chrono();
            try
            {
                AssemblyResolve.Stop();
                AssemblyResolve.Clear();

                _refreshRunSourceConfig = true;
                _refreshProjectConfig   = true;

                IGenerateAndExecute generateAndExecute = GetGenerateAndExecuteManager().New();
                _GenerateCodeAndCompile_v2(generateAndExecute, code, compileWithoutProject);
                if (generateAndExecute.Compiler.HasError())
                {
                    return;
                }

                MethodInfo runMethod  = generateAndExecute.GetAssemblyRunMethod();
                MethodInfo initMethod = generateAndExecute.GetAssemblyInitMethod();
                MethodInfo endMethod  = generateAndExecute.GetAssemblyEndMethod();

                AssemblyResolve.Start();
                if (useNewThread)
                {
                    _runCodeThread = new Thread(new ThreadStart(() => _Run(runMethod, initMethod, endMethod)));
                    _runCodeThread.CurrentCulture = FormatInfo.CurrentFormat.CurrentCulture;
                    _runCodeThread.SetApartmentState(ApartmentState.STA);
                    _runCodeThread.Start();
                }
                else
                {
                    Trace.WriteLine("execute on main thread");
                    _Run(runMethod, initMethod, endMethod);
                }

                bOk = true;
            }
            catch
            {
                bError = true;
                throw;
            }
            finally
            {
                if (!bOk && EndRun != null)
                {
                    EndRun(bError);
                }
            }
        }