public GeneratorParameters() { Phase = 0; CurrentStart = 0; CurrentEnd = 0; CurrentState = 0; }
public override void Filter(bool[,] panelConfig, GeneratorState state) { var history = state.PanelHistory; if (history.Count < 1) { return; } var indexOfLastFoot = PanelHistoryUtil.GetLastIndexOfLastFoot(history, state.CurrentFoot); var startCol = history[indexOfLastFoot].panel[1]; switch (state.CurrentFoot) { case Foot.Left: FilterLeftOfStartColumn(panelConfig, startCol, maxStretchDistance); // Prevent left foot from stretching too far to the left FilterRightOfStartColumn(panelConfig, startCol, maxCrossoverDistance); // Prevent left foot from crossing over too far to the right break; case Foot.Right: FilterRightOfStartColumn(panelConfig, startCol, maxStretchDistance); FilterLeftOfStartColumn(panelConfig, startCol, maxCrossoverDistance); break; } }
public bool MoveNext() { GeneratorState currentState = this.Iterator.State; switch (currentState) { case GeneratorState.Closed: case GeneratorState.AwaitingReturn: this.Current = EcmaValue.Undefined; return(false); } GeneratorResumeState resumeState = this.Context.ResumeState; try { this.Current = GetNextValue(resumeState, this.Context.ResumeValue); } catch (GeneratorClosedException ex) { this.Current = ex.ReturnValue; if (resumeState != GeneratorResumeState.Return) { return(false); } throw; } return(resumeState != GeneratorResumeState.Resume || this.Iterator.State != GeneratorState.Closed); }
public override void Filter(bool[,] panelConfig, GeneratorState state) { var history = state.PanelHistory; if (history.Count < 2) { return; } var lastPanelIndex = PanelHistoryUtil.GetLastIndexOfLastNote(history); var lastFootIndex = PanelHistoryUtil.GetIndexOfLastFoot(history, lastPanelIndex, history[lastPanelIndex].foot); var lastFootPanel = history[lastFootIndex].panel; var historyRow = lastFootPanel[0]; var historyCol = lastFootPanel[1]; for (var row = 0; row < PanelConfigUtil.maxRows; row++) { for (var col = 0; col < PanelConfigUtil.maxColumns; col++) { if (Math.Abs(row - historyRow) > maxHorizontalDistance || Math.Abs(col - historyCol) > maxVerticalDistance) { panelConfig[row, col] = false; } } } }
// Update is called once per frame void FixedUpdate() { if (!pv.IsMine) { return; } if (currentstate == GeneratorState.CoolDown) { if (CoolDownTimeLeft > 0) { CoolDownTimeLeft = CoolDownTimeLeft - Time.deltaTime * CoolDownSpeed; } if (CoolDownTimeLeft <= 0) { currentstate = GeneratorState.Ready; } } if (currentstate == GeneratorState.Ready) { int i = Mathf.RoundToInt(Random.Range(0, randomItem.Length)); //Info Player That smthing has be generated PickUpItem = PhotonNetwork.Instantiate(Path.Combine("PhotonPrefabs", randomItem[i]), GeneratePoint.position, Quaternion.identity); CoolDownTimeLeft = CoolDownTime; currentstate = GeneratorState.Waiting; } if (currentstate == GeneratorState.Waiting) { if (PickUpItem == null) { currentstate = GeneratorState.CoolDown; } } }
void FixedUpdate() { switch (_state) { case GeneratorState.RESET: if (_prevState != _state) { ResetBehaviour(); } break; case GeneratorState.START: if (_prevState != _state) { _startPlatformRef = _platformFactory.InstantiateStartPlatform(_startPosY); _state = GeneratorState.GENERATE; } break; case GeneratorState.GENERATE: GenerateBehaviour(); break; case GeneratorState.DEAD: if (_prevState != _state) { DeadBehaviour(); } break; } _prevState = _state; }
/// <summary> /// Constructor /// </summary> /// <param name="errorMessage">MetadataConversionError</param> /// <remarks> </remarks> public ProxyGenerationError(MetadataConversionError errorMessage) { m_ErrorGeneratorState = GeneratorState.GenerateCode; m_IsWarning = errorMessage.IsWarning; m_Message = errorMessage.Message; m_MetadataFile = String.Empty; m_LineNumber = -1; m_LinePosition = -1; }
public void Generate(int thumbnailWidth, int secondStep, string thumbnailDir, string filepath, NamedPipeClient<string> mediaScribeServer) { if (State != GeneratorState.Stopped) throw new Exception("ThumbnailGenerator must be in a 'stopped' state before we can start generating thumbnails. Currently, it is in state: " + State.ToString()); State = GeneratorState.Running; GenerateImpl(thumbnailWidth, secondStep, thumbnailDir, filepath, mediaScribeServer); State = GeneratorState.Stopped; }
/// <summary> /// Constructor /// </summary> /// <param name="generatorState"></param> /// <param name="fileName"></param> /// <param name="errorException">An XmlException</param> /// <remarks> </remarks> public ProxyGenerationError(GeneratorState generatorState, string fileName, XmlException errorException) { m_ErrorGeneratorState = generatorState; m_IsWarning = false; m_Message = errorException.Message; m_MetadataFile = fileName; m_LineNumber = errorException.LineNumber; m_LinePosition = errorException.LinePosition; }
/// <summary> /// Constructor /// </summary> /// <param name="generatorState"></param> /// <param name="fileName"></param> /// <param name="errorException">An IOException</param> /// <param name="isWarning">An IOException</param> /// <remarks> </remarks> public ProxyGenerationError(GeneratorState generatorState, string fileName, Exception errorException, bool isWarning) { m_ErrorGeneratorState = generatorState; m_IsWarning = isWarning; m_Message = errorException.Message; m_MetadataFile = fileName; m_LineNumber = -1; m_LinePosition = -1; }
public void SetState(int generatorId, GeneratorState newState) { var generator = GetOrAdd(generatorId); var oldState = generator.State; generator.SetState(newState); if (oldState != newState) { GameEvents.OnGeneratorStateChanged(oldState, generator.State, generator); } }
public override void Filter(bool[,] panelConfig, GeneratorState state) { if (foot != state.CurrentFoot) { return; } for (var row = 0; row < PanelConfigUtil.maxRows; row++) { panelConfig[row, column] = false; } }
public void TurnHandle(int id) { if (!handleTurned) { handleTurned = true; VOSequencer.ReplaceEvent("06_GREENHOUSE_draganddropfunnel_1"); } feederPipes[id].UsePipe(); currentState = GeneratorState.Ready; GenerateSeed(id); StartCoroutine(AddOrbitors(id)); }
private void OnGeneratorStateChanged(GeneratorState oldState, GeneratorState newState, GeneratorInfo targetGenerator) { if (generator != null) { if (generator.IsDependent) { if (generator.RequiredGeneratorId == targetGenerator.GeneratorId) { UpdateResearchButtonInteractability(); } } } }
public override void Filter(bool[,] panelConfig, GeneratorState state) { var history = state.PanelHistory; if (history.Count < 1) { return; } var lastPanel = history.Last().panel; DisableAdjacentRows(panelConfig, lastPanel); }
public void GenerateGameDataMBINTable() { // TODO: HACK, for debugging the test // Change MAX to restrict how many files will be processed. // For unrestricted, set to int.MaxValue const int MAX = int.MaxValue; // TODO FIXME! should be int.MaxValue; var table = new GameDataMBIN.Table(); if (File.Exists(table.FilePath)) { throw new APIException($"A {table.Name} table already exists!\n{table.FilePath}"); } string[] files = Directory.GetFiles(RunSettings.GameDataDir, "*.MBIN*", SearchOption.AllDirectories); Array.Resize(ref files, Math.Min(MAX, files.Length)); CurrentState = new GeneratorState(table, files); string logPath = Logger.GetLogPath("GameDataMBIN.log"); using (CurrentState.LogStream = new StreamWriter(logPath) { AutoFlush = true }) { int maxThreads = RunSettings.MaxConcurrentThreads; this.runners = new ThreadRunner[maxThreads]; for (int i = 0; i < maxThreads; i++) { string file = CurrentState.NextFile(); if (file == null) { break; } runners[i] = new ThreadRunner(file, OnThreadFinished); new Thread(new ThreadStart(runners[i].Execute)).Start(); } while (!CurrentState.IsFinished) { Thread.Sleep(10); // ms } table.Save(); } }
public void QuickSetup(Generator generator) { CurrentStart = generator.StartPhase; Phase = CurrentStart + generator.Offset; switch (generator.LoopMode) { case LoopMode.Continuous: case LoopMode.LoopUntilNoteOff: if (Phase >= generator.EndPhase) { //phase is greater than the end index so generator is finished CurrentState = GeneratorState.Finished; } else if (Phase >= generator.LoopEndPhase) { //phase is greater than the loop end point so generator is in post loop CurrentState = GeneratorState.PostLoop; CurrentEnd = generator.EndPhase; } else if (Phase >= generator.LoopStartPhase) { //phase is greater than loop start so we are inside the loop CurrentState = GeneratorState.Loop; CurrentEnd = generator.LoopEndPhase; CurrentStart = generator.LoopStartPhase; } else { //phase is less than the loop so generator is in pre loop CurrentState = GeneratorState.PreLoop; CurrentEnd = generator.LoopStartPhase; } break; default: CurrentEnd = generator.EndPhase; if (Phase >= CurrentEnd) { CurrentState = GeneratorState.Finished; } else { CurrentState = GeneratorState.PostLoop; } break; } }
private void OnGeneratorStateChanged(GeneratorState oldState, GeneratorState newState, GeneratorInfo info) { if (generator != null && (generator.GeneratorId == info.GeneratorId)) { switch (newState) { case GeneratorState.Unlockable: { unlockButton.interactable = true; } break; case GeneratorState.Locked: { unlockButton.interactable = false; } break; } } }
public override void Filter(bool[,] panelConfig, GeneratorState state) { var history = state.PanelHistory; var historyIndex = PanelHistoryUtil.GetLastIndexOfLastNote(history); var noteCounter = 0; while (historyIndex >= 0 && noteCounter < numNotes) { var historyItem = history[historyIndex]; var panel = historyItem.panel; var row = panel[0]; var col = panel[1]; panelConfig[row, col] = false; DisableAdjacentRows(panelConfig, row, col); noteCounter++; historyIndex = PanelHistoryUtil.GetIndexOfLastFoot(history, historyIndex, historyItem.foot); } }
void SetGeneratorState(GeneratorState newState) { switch (newState) { case GeneratorState.Ready: if (seedDraged) { animator.SetInteger("AnimState", 0); } readyForHandle = true; break; case GeneratorState.BuildingSeed: animator.SetInteger("AnimState", 1); DisableHandles(); readyForHandle = false; break; case GeneratorState.WaitingForOrbitors: readyForHandle = true; break; case GeneratorState.AddingOrbitors: animator.SetInteger("AnimState", 2); readyForHandle = true; break; case GeneratorState.SeedComplete: if (currentState == GeneratorState.Ready) { return; } readyForHandle = true; break; default: readyForHandle = true; break; } currentState = newState; }
public override void Filter(bool[,] panelConfig, GeneratorState state) { if (state.PanelHistory.Any() || // Only apply this rule to the first note generated foot != state.CurrentFoot) { return; } for (var col = 0; col < PanelConfigUtil.maxColumns; col++) { if (col == column) { continue; } for (var row = 0; row < PanelConfigUtil.maxRows; row++) { panelConfig[row, col] = false; } } }
// Use this for initialization void Start() { _startPosY = Camera.main.transform.position.y - Camera.main.orthographicSize; float sizeX = Camera.main.orthographicSize * Screen.width / Screen.height; _areaMinX = Camera.main.transform.position.x - sizeX; _areaMaxX = Camera.main.transform.position.x + sizeX; foreach (FactoryTypeInfo fti in factories) { fti.factory.SetBounds(_areaMinX, _areaMaxX); if (fti.factory is PlatformFactory) { _platformFactory = fti.factory as PlatformFactory; } } _state = GeneratorState.RESET; _prevState = GeneratorState.IDLE; }
public void QuickSetup(Generator generator) { CurrentStart = generator.StartPhase; Phase = CurrentStart + generator.Offset; switch (generator.LoopMode) { case LoopMode.Continuous: case LoopMode.LoopUntilNoteOff: if (Phase >= generator.EndPhase) {//phase is greater than the end index so generator is finished CurrentState = GeneratorState.Finished; } else if (Phase >= generator.LoopEndPhase) {//phase is greater than the loop end point so generator is in post loop CurrentState = GeneratorState.PostLoop; CurrentEnd = generator.EndPhase; } else if (Phase >= generator.LoopStartPhase) {//phase is greater than loop start so we are inside the loop CurrentState = GeneratorState.Loop; CurrentEnd = generator.LoopEndPhase; CurrentStart = generator.LoopStartPhase; } else {//phase is less than the loop so generator is in pre loop CurrentState = GeneratorState.PreLoop; CurrentEnd = generator.LoopStartPhase; } break; default: CurrentEnd = generator.EndPhase; if (Phase >= CurrentEnd) CurrentState = GeneratorState.Finished; else CurrentState = GeneratorState.PostLoop; break; } }
public override void Filter(bool[,] panelConfig, GeneratorState state) { var history = state.PanelHistory; if (history.Count < numSteps) { return; } var lastPanel = history[history.Count - numSteps].panel; if (maxRepetitions == 0) // Special case { panelConfig[lastPanel[0], lastPanel[1]] = false; return; } var historyIndex = history.Count - (numSteps * 2); var historyCounter = 0; var repetitionCounter = 0; while (historyIndex > 0 && historyCounter < maxRepetitions) { var panel = history[historyIndex].panel; if (panel[0] == lastPanel[0] && panel[1] == lastPanel[1]) { repetitionCounter++; } historyIndex -= numSteps; historyCounter++; } if (repetitionCounter >= maxRepetitions) { panelConfig[lastPanel[0], lastPanel[1]] = false; } }
/// <summary> /// /// </summary> /// <param name="generatorState"></param> public void ChangeState(ref GeneratorState generatorState) { generatorState.AppendText("\r\n"); }
/// <summary> /// /// </summary> /// <param name="generatorState"></param> public void ChangeState(ref GeneratorState generatorState) { --generatorState.TabCount; }
/// <summary> /// /// </summary> /// <param name="generatorState"></param> public void ChangeState(ref GeneratorState generatorState) { //DO NOTHING }
public int MoveBackward(ref GeneratorState state, bool allowMovePastRealizedItem, int count) { if (IsMoveAllowed(allowMovePastRealizedItem)) { if (count <= state.Offset) { state.Offset -= count; } else { count = state.Offset + 1; state.Block = Prev; state.Offset = state.Block.ItemCount - 1; state.Count -= state.Block.ItemCount; } state.ItemIndex -= count; } return count; }
public void MoveBackward(ref GeneratorState state, bool allowMovePastRealizedItem) { if (IsMoveAllowed(allowMovePastRealizedItem)) { if (--state.Offset < 0) { state.Block = Prev; state.Offset = state.Block.ItemCount - 1; state.Count -= state.Block.ItemCount; } state.ItemIndex -= 1; } }
public void SetState(GeneratorState newState) { State = newState; }
public override bool CheckCondition(GeneratorState state) { throw new NotImplementedException(); }
//------------------------------------------------------ // // Private Methods // //------------------------------------------------------ void MoveToPosition(GeneratorPosition position, GeneratorDirection direction, bool allowStartAtRealizedItem, ref GeneratorState state) { ItemBlock block = _itemMap; if (block == null) return; // this can happen in event-leapfrogging situations (Dev11 283413) int itemIndex = 0; // first move to the indexed (realized) item if (position.Index != -1) { // find the right block int itemCount = 0; int index = position.Index; block = block.Next; while (index >= block.ContainerCount) { itemCount += block.ItemCount; index -= block.ContainerCount; itemIndex += block.ItemCount; block = block.Next; } // set the position state.Block = block; state.Offset = index; state.Count = itemCount; state.ItemIndex = itemIndex + index; } else { state.Block = block; state.Offset = 0; state.Count = 0; state.ItemIndex = itemIndex - 1; } // adjust the offset - we always set the state so it points to the next // item to be generated. int offset = position.Offset; if (offset == 0 && (!allowStartAtRealizedItem || state.Block == _itemMap)) { offset = (direction == GeneratorDirection.Forward) ? 1 : -1; } // advance the state according to the offset if (offset > 0) { state.Block.MoveForward(ref state, true); -- offset; while (offset > 0) { offset -= state.Block.MoveForward(ref state, allowStartAtRealizedItem, offset); } } else if (offset < 0) { if (state.Block == _itemMap) { state.ItemIndex = state.Count = ItemsInternal.Count; } state.Block.MoveBackward(ref state, true); ++ offset; while (offset < 0) { offset += state.Block.MoveBackward(ref state, allowStartAtRealizedItem, -offset); } } }
public void MoveForward(ref GeneratorState state, bool allowMovePastRealizedItem) { if (IsMoveAllowed(allowMovePastRealizedItem)) { state.ItemIndex += 1; if (++state.Offset >= ItemCount) { state.Block = Next; state.Offset = 0; state.Count += ItemCount; } } }
public static void OnGeneratorStateChanged(GeneratorState oldState, GeneratorState newState, GeneratorInfo generator) => GeneratorStateChanged?.Invoke(oldState, newState, generator);
public int MoveForward(ref GeneratorState state, bool allowMovePastRealizedItem, int count) { if (IsMoveAllowed(allowMovePastRealizedItem)) { if (count < ItemCount - state.Offset) { state.Offset += count; } else { count = ItemCount - state.Offset; state.Block = Next; state.Offset = 0; state.Count += ItemCount; } state.ItemIndex += count; } return count; }
// Start is called before the first frame update void Awake() { pv = GetComponent <PhotonView>(); currentstate = GeneratorState.Ready; randomItem = new string[] { "JetPickUp", "SpeedUpPickUp" }; }
public abstract void Filter(bool[,] panelConfig, GeneratorState state);