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;
}
}
}
}
public GeneratorParameters()
{
Phase = 0;
CurrentStart = 0;
CurrentEnd = 0;
CurrentState = 0;
}
// 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;
}
/// <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;
}
/// <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" };
}
/// <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;
}
public abstract void Filter(bool[,] panelConfig, GeneratorState state);
