void reset() { phase = PhaseType.None; retention = 0; average = 0; retention0 = 0; retentionTime = 0; sigma = 0; width = 0; hwidth = 0; swidth = 0; height = 0; purity = 0; recovery = 0; totm = 0; totmup = 0; totmlp = 0; willElute = true; eluted = false; intIt = 0; intItSet = false; filterSigma = 0; }
public void generalInit() { int ncomps = inParams.comps.Count; intit = 0; intamountu = 0; intamountl = 0; eeDone = false; compEluted = new bool[ncomps]; if (inParams.runMode == RunModeType.UpperPhase) { curPhase = PhaseType.Upper; } else if (inParams.runMode == RunModeType.LowerPhase) { curPhase = PhaseType.Lower; } else if (inParams.runMode == RunModeType.Intermittent) { curPhase = inParams.intStartPhase; } else { curPhase = PhaseType.Both; } }
/// <summary> /// Initializes the Data needed to process the Information. /// </summary> /// <param name="data">The data.</param> /// <param name="phases">The phases of the program.</param> /// <param name="previousPhases">The phases of the previous program.</param> /// <param name="Type">The type of Phase (Plan, Design, etc).</param> public void initialize(Data data, Phases phases, Phases previousPhases, PhaseType Type) { this.data = data; this.phases = phases; this.previousPhases = previousPhases; this.Type = Type; }
//set the type and the Time of the Phase public TrafficPhase(PhaseType type, int duration) { Type = type; Duration = duration; Timer.Interval = 1000; Timer.Tick += new EventHandler(Timer_Tick); }
public override void UpdatePhase(PhaseType pt) { FormRef.Invoke((MethodInvoker) delegate { FormRef.UpdatePhase(pt); }); }
public override void EnterPhaseNotify(PhaseType phaseType) { CEnterPhaseType cEnterPhaseType = new CEnterPhaseType(); cEnterPhaseType.AddContent("phaseType", phaseType); ClientManager.GetSingleInstance().SendProtocol(cEnterPhaseType); }
/// <summary> /// 切换当前玩家一般在结束回合后调用 /// </summary> /// <param name="player"></param> public void ChangeCurrentPlayer() { currentTurnNumber++; currentPhaseType = PhaseType.Unknown; currentPlayer = currentPlayer == myPlayer ? opponentPlayer : myPlayer; currentPlayer.StartTurn(); }
public EncryptionPassPhase(DateTime startTime, DateTime endTime, PhaseType name) { this.StartTime = startTime; this.EndTime = endTime; this.PhaseName = name; this.Duration = endTime - startTime; }
private void HandleAdditionalPhaseOptions(PhaseType selected) { switch (selected) { case PhaseType.FullRange: break; case PhaseType.CenterInterpolation: case PhaseType.OldCenterInterpolation: Show(TbCenterSpanLength); Show(LbCentralSpan); break; case PhaseType.SpecificRange: case PhaseType.SpecificFreqRange: Show(LbRangeStart); Show(LbRangeEnd); Show(TbRangeStart); Show(TbRangeEnd); break; default: throw new ArgumentOutOfRangeException(); } }
private double Start() { if ((N2 > 15.0) && !starved) { // minimum 15% N2 needed for start cranking = true; // provided for sound effects signal if (N2 < IdleN2) { N2 = Seek(N2, IdleN2, 2.0, N2 / 2.0); N1 = Seek(N1, IdleN1, 1.4, N1 / 2.0); EGT_degC = Seek(EGT_degC, TAT + 363.1, 21.3, 7.3); fuelFlow_pph = Seek(fuelFlow_pph, IdleFF, 103.7, 103.7); OilPressure_psi = N2 * 0.62; ConsumeFuel(); } else { phase = PhaseType.Run; running = true; starter = false; cranking = false; } } else { // no start if N2 < 15% phase = PhaseType.Off; starter = false; } return(0.0); }
LinearGradientBrush createPhaseBrush(PhaseType phase, float part = 0.5f) { LinearGradientBrush phaseBrush = new LinearGradientBrush(); Color upColor = Colors.Yellow; Color lpColor = Colors.Lime; phaseBrush.StartPoint = new Point(0.5, 0); phaseBrush.EndPoint = new Point(0.5, 1); switch (phase) { case PhaseType.Upper: phaseBrush.GradientStops.Add(new GradientStop(upColor, 0)); break; case PhaseType.Lower: phaseBrush.GradientStops.Add(new GradientStop(lpColor, 0)); break; case PhaseType.Both: phaseBrush.GradientStops.Add(new GradientStop(upColor, 0)); phaseBrush.GradientStops.Add(new GradientStop(upColor, part)); phaseBrush.GradientStops.Add(new GradientStop(lpColor, part)); phaseBrush.GradientStops.Add(new GradientStop(lpColor, 1)); break; } return(phaseBrush); }
private void SetDefaults() { N1 = N2 = 0.0; engineType = EngineType.Turbine; MilThrust = 10000.0; MaxThrust = 10000.0; BypassRatio = 0.0; TSFC = 0.8; correctedTSFC = TSFC; ATSFC = 1.7; IdleN1 = 30.0; IdleN2 = 60.0; MaxN1 = 100.0; MaxN2 = 100.0; Augmented = 0; AugMethod = 0; Injected = 0; BleedDemand = 0.0; ThrottlePos = 0.0; AugmentCmd = 0.0; InletPosition = 1.0; NozzlePosition = 1.0; Augmentation = false; Injection = false; Reversed = false; Cutoff = true; phase = PhaseType.Off; Stalled = false; Seized = false; Overtemp = false; Fire = false; EGT_degC = 0.0; }
public Phase(AnalyzedPhasedConstruct parent, PhaseType c, int phaseNum, LocalizedString?name) { type = c; title = name; index = phaseNum; this.parent = parent; }
public static void HexDeselected(PhaseType currentPhase) { switch (currentPhase) { case PhaseType.InitialDisclosure: break; case PhaseType.InitialBuying: break; case PhaseType.Guerilla: //break; case PhaseType.Combat: UnitController.DeselectUnit(); break; case PhaseType.Recruitment: break; case PhaseType.Disclosing: break; case PhaseType.DisclosingBuying: break; } }
private string GetFileName(PhaseType type) { var name = GetTypeName(type.TypeSymbol); var p = name.IndexOf("<"); if (p >= 0) name = name.Substring(0, p); return name.Replace('.', Path.DirectorySeparatorChar) + ".hx"; }
public Unit(Unit unit) { pos = unit.pos; m = unit.m; phase = unit.phase; incol = unit.incol; zone = unit.zone; }
public static int?DefaultHP(this PhaseType st) { if (st == PhaseType.TIMEOUT || st == PhaseType.DIALOGUE) { return(1000000000); } return(null); }
/// <summary> /// Assigns situation-specific default values to the ValueRange. The given values will be /// used by draw() unless they are specifically overridden by a ConfigNode. Does not throw /// exceptions. /// </summary> /// <param name="dist">The distribution from which the value will be drawn.</param> /// <param name="type">The description of orbit position that is used.</param> /// <param name="epoch">The time at which the orbit position should be measured.</param> /// <param name="min">The minimum value allowed for distributions. May be unused.</param> /// <param name="max">The maximum value allowed for distributions. May be unused.</param> /// <param name="avg">The mean value returned. May be unused.</param> /// <param name="stddev">The standard deviation of values returned. May be unused.</param> internal PhaseRange(Distribution dist, PhaseType type = PhaseType.MeanAnomaly, EpochType epoch = EpochType.GameStart, double min = 0.0, double max = 1.0, double avg = 0.0, double stddev = 0.0) : base(dist, min, max, avg, stddev) { this.type = type; this.epoch = epoch; }
//Setting Constuctors #region Constructors public Film(string title, DateTime releaseDate, int duration, string rating, string director, string cast, decimal sales, PhaseType phase) : base(title, releaseDate, duration, rating, cast, sales, phase) { //Setting Values Director = director; Type = "Film"; }
public Phase(Village village, PhaseType initialPhase) { this.village = village; this.type = initialPhase; village.ActionExecuted += new EventHandler<ActionEventArgs>(OnActionExecuted); votes = new MafiaVoteCounter(village.AliveMembers); votes.MajorityReached += new EventHandler<MajorityReachedEventArgs<VillageMember>>(OnMajorityReached); }
public HaxeEmitterContext(HaxeEmitter emitter, PhaseType type) { Emitter = emitter; CurrentType = type; _writerStack = new Stack <IWriter>(); Writer = new InMemoryWriter(); CurrentExceptionName = new Stack <string>(); CurrentForIncrementors = new Stack <IEnumerable <ExpressionSyntax> >(); }
public Phase(string name, PhaseType phaseType, Point mimPoint, Point maxPoint) { this.Name = name; this.Type = phaseType; UniversalObjectsInside = new List <UniversalObject>(); ObjectToRemoveFromExistanceOnNextOccasion = new List <UniversalObject>(); this.MinPoint = mimPoint; this.MaxPoint = maxPoint; }
//Setting Constuctors #region Constructors public Show(string title, DateTime releaseDate, int duration, int numOfEpisodes, string rating, string creator, string cast, decimal sales, PhaseType phase) : base(title, releaseDate, duration, rating, cast, sales, phase) { //Setting Values Creator = creator; NumberOfEpisodes = numOfEpisodes; Type = "Show"; }
public void TestCreateTemplateWithProcess(PhaseType phaseType, PhaseDate phaseDate, CommonEnums phaseMemo, EndFlag endFlag, EndReason endReason) { var handler = new DefaultManager(); var request = BuildCreateTemplateWithProcessRequest(OptionPhaseProcess, OptionEndReason, phaseType, phaseMemo, endFlag, endReason); var response = handler.Send <CreateTemplateResponse>(TemplateEndPoint, JsonConvert.SerializeObject(request), HttpMethod.POST); PrAssert.That(response, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.OK)); request[IdParam] = response.Result.Id; ReadAndVerifyData(request); }
public EnterPhaseEffectProcess(PhaseType phaseType, Player ownerPlayer) : base(ownerPlayer, "进入阶段") { effectProcessType = EffectProcessType.RemoveAfterFinish; this.phaseType = phaseType; finishAction = () => { duelScene.ResetCurrentPointCardAllowedOperation(); duelScene.CheckAllEffectProcess(); }; }
private void SetPositionProcess() { // 呉氏の初期位置への移動 popupObject.transform.position = Vector3.MoveTowards(popupObject.transform.position, kureshiTargetPos, Time.deltaTime * 4.0f); if (popupObject.transform.position == kureshiTargetPos) { AudioManager.Instance.PlaySE(Constant.SET_POSITION_SE); _ePhaseType = PhaseType.USER; } }
/** * ユーザ操作終了後の待ち時間 */ private void WaitProcess() { waitTime += Time.deltaTime; if (waitTime >= WAIT_TIME) { waitTime = 0; _ePhaseType = PhaseType.END; } return; }
public Ability(AbilityType type, PhaseType phase, LimitType limit, string text) { if (text == null) throw new ArgumentNullException("text"); this.type = type; this.phase = phase; this.limit = limit; this.text = text; }
public Phase(int tick, PhaseType phaseType) : this() { PhaseId = (int)phaseType | (tick << TickBitShift); Debug.Assert(PhaseType == phaseType, "Phase type wrong"); Debug.Assert(Tick == tick, "Tick wrong"); }
/** 設定。 */ public void Set(int a_value_x, int a_value_y, PhaseType a_phasetype) { //value_x this.value_x = a_value_x; //value_y this.value_y = a_value_y; //phasetype this.phasetype = a_phasetype; }
public void Switch(PhaseType phaseType) { if (Purpose == TrafficLightPurpose.Traffic) { YellowLight.State = (phaseType == PhaseType.Attention) || (phaseType == PhaseType.Prepare) ? LampState.On : LampState.Off; } RedLight.State = (phaseType == PhaseType.Stop) || (phaseType == PhaseType.Prepare) ? LampState.On : LampState.Off; GreenLight.State = (phaseType == PhaseType.Go) ? LampState.On : LampState.Off; Invalidate(); Application.DoEvents(); }
public Instant(int tick, PhaseType phaseType, byte unitSequence) : this() { InstantId = unitSequence | (((int)phaseType) << PhaseTypeBitShift) | (tick << TickBitShift); Debug.Assert(UnitSequence == unitSequence, "UnitSequence wrong"); Debug.Assert(PhaseType == phaseType, "Phase type wrong"); Debug.Assert(Tick == tick, "Tick wrong"); }
public Game() { started = false; players = new WebSocket[2]; viewers = new List<WebSocket>(); field = new Field(this); buffer = new ChangesBuffer(this); Forts = new byte[2]{ 2, 2 }; blocks = new Block[2]{ null, null }; inask = new Cord[2]{ new Cord(), new Cord() }; phase = PhaseType.Displacing; player = 0; }
private void OnNeighborAdd(Cube cube1, Cube.Side side1, Cube cube2, Cube.Side side2) { Log.Debug("Neighbor add: {0}.{1} <-> {2}.{3}", cube1.UniqueId, side1, cube2.UniqueId, side2); CubeWrapper wrapper1 = (CubeWrapper)cube1.userData; CubeWrapper wrapper2 = (CubeWrapper)cube2.userData; if (wrapper1 != null && wrapper2 != null) { if ((wrapper1.mType == CubeType.SELECTOR && wrapper2.mType == CubeType.SELECTABLE) || (wrapper2.mType == CubeType.SELECTOR && wrapper1.mType == CubeType.SELECTABLE)) { Cube.Side selectorSide; Cube.Side selectableSide; CubeWrapper selectorWrapper; CubeWrapper selectableWrapper; if (wrapper1.mType == CubeType.SELECTOR) { selectorSide = side1; selectableSide = side2; selectorWrapper = wrapper1; selectableWrapper = wrapper2; } else { selectorSide = side2; selectableSide = side1; selectorWrapper = wrapper2; selectableWrapper = wrapper1; } if (selectorSide == Cube.Side.BOTTOM) { switch (currentPhase) { case (PhaseType.MODESELECT): if (selectableSide == Cube.Side.TOP) { currentMode = GameModes.FREELIB; currentPhase = PhaseType.NAMESELECT; readyToChangeState = true; } else if (selectableSide == Cube.Side.BOTTOM) { currentMode = GameModes.FREETHEME; currentPhase = PhaseType.NAMESELECT; readyToChangeState = true; } break; case (PhaseType.NAMESELECT): currentPlayer = nameSelector(selectableSide, selectableWrapper); currentPhase = PhaseType.THEMESELECT; readyToChangeState = true; break; case (PhaseType.BEATSELECT): string sample = beatSelector(selectableSide, selectableWrapper); sampleMusic = Sounds.CreateSound(sample); if (mMusic.IsPlaying) mMusic.Pause(); sampleMusic.Play(1, -1); currentPhase = PhaseType.BEATSELECT2; readyToChangeState = true; break; case (PhaseType.THEMESELECT): currentTheme = themeSelector(selectableSide, selectableWrapper); currentPhase = PhaseType.BEATSELECT; readyToChangeState = true; break; default: break; } } } } }
private void PhaseChange(PhaseType phaseType, byte p, byte channel = 0) { phase = phaseType; player = p; ToClient mes = new ToClient { action = 1, player = p, phase = phaseType }; if (phase == PhaseType.Asking) { mes.agressorx = inask[p - 1].x; mes.agressory = inask[p - 1].y; mes.targetx = inask[Opponent(p) - 1].x; mes.targety = inask[Opponent(p) - 1].y; } Send(mes, channel); if (movepassed && phase != PhaseType.Attack) movepassed = false; inverted = false; }
/** Expand Machine instruction into operation type and arguments and put into proper machine instruction container also expands scaler alpha machine instructions if required */ bool ExpandMachineInstruction() { // now push instructions onto MachineInstructions container // assume that an instruction will be expanded bool passed = true; if ( opType != MachineInstruction.Nop ) { // a machine instruction will be built // this is currently the last one being built so keep track of it if ( instructionPhase == PhaseType.PHASE2ALU ) { secondLastInstructionPos = lastInstructionPos; lastInstructionPos = phase2ALU_mi.Count; } switch ( opType ) { case MachineInstruction.ColorOp1: case MachineInstruction.ColorOp2: case MachineInstruction.ColorOp3: { AddMachineInst( instructionPhase, (int)opType ); AddMachineInst( instructionPhase, symbolTypeLib[ (int)opInst ].pass2Data ); // send all parameters to machine inst container for ( int i = 0; i <= argCnt; i++ ) { AddMachineInst( instructionPhase, opParams[ i ].Arg ); AddMachineInst( instructionPhase, (int)opParams[ i ].MaskRep ); AddMachineInst( instructionPhase, opParams[ i ].Mod ); // check if source register read is valid in this phase passed &= IsRegisterReadValid( instructionPhase, i ); } // record which registers were written to and in which phase // opParams[0].Arg is always the destination register r0 -> r5 UpdateRegisterWriteState( instructionPhase ); } break; case MachineInstruction.SetConstants: AddMachineInst( instructionPhase, (int)opType ); AddMachineInst( instructionPhase, opParams[ 0 ].Arg ); // dst AddMachineInst( instructionPhase, constantsPos ); // index into constants array break; case MachineInstruction.PassTexCoord: case MachineInstruction.SampleMap: // if source is a temp register than place instruction in phase 2 Texture ops if ( ( opParams[ 1 ].Arg >= Gl.GL_REG_0_ATI ) && ( opParams[ 1 ].Arg <= Gl.GL_REG_5_ATI ) ) { instructionPhase = PhaseType.PHASE2TEX; } AddMachineInst( instructionPhase, (int)opType ); AddMachineInst( instructionPhase, opParams[ 0 ].Arg ); // dst AddMachineInst( instructionPhase, opParams[ 1 ].Arg ); // coord AddMachineInst( instructionPhase, (int)opParams[ 1 ].MaskRep + Gl.GL_SWIZZLE_STR_ATI ); // swizzle // record which registers were written to and in which phase // opParams[0].Arg is always the destination register r0 -> r5 UpdateRegisterWriteState( instructionPhase ); break; case MachineInstruction.Tex: // PS_1_1 emulation - turn CISC into RISC - phase 1 AddMachineInst( instructionPhase, (int)MachineInstruction.SampleMap ); AddMachineInst( instructionPhase, opParams[ 0 ].Arg ); // dst // tex tx becomes texld rx, tx with x: 0 - 3 AddMachineInst( instructionPhase, opParams[ 0 ].Arg - Gl.GL_REG_0_ATI + Gl.GL_TEXTURE0_ARB ); // interp // default to str which fills rgb of destination register AddMachineInst( instructionPhase, Gl.GL_SWIZZLE_STR_ATI ); // swizzle // record which registers were written to and in which phase // opParams[0].Arg is always the destination register r0 -> r5 UpdateRegisterWriteState( instructionPhase ); break; case MachineInstruction.TexCoord: // PS_1_1 emulation - turn CISC into RISC - phase 1 AddMachineInst( instructionPhase, (int)MachineInstruction.PassTexCoord ); AddMachineInst( instructionPhase, opParams[ 0 ].Arg ); // dst // texcoord tx becomes texcrd rx, tx with x: 0 - 3 AddMachineInst( instructionPhase, opParams[ 0 ].Arg - Gl.GL_REG_0_ATI + Gl.GL_TEXTURE0_ARB ); // interp // default to str which fills rgb of destination register AddMachineInst( instructionPhase, Gl.GL_SWIZZLE_STR_ATI ); // swizzle // record which registers were written to and in which phase // opParams[0].Arg is always the destination register r0 -> r5 UpdateRegisterWriteState( instructionPhase ); break; } // end of switch (opType) } // end of if (opType != mi_NOP) if ( do_Alpha ) { // process alpha channel // // a scaler machine instruction will be built // this is currently the last one being built so keep track of it if ( instructionPhase == PhaseType.PHASE2ALU ) { secondLastInstructionPos = lastInstructionPos; lastInstructionPos = phase2ALU_mi.Count; } MachineInstruction alphaoptype = (MachineInstruction)( MachineInstruction.AlphaOp1 + argCnt - 1 ); AddMachineInst( instructionPhase, (int)alphaoptype ); AddMachineInst( instructionPhase, symbolTypeLib[ (int)opInst ].pass2Data ); // put all parameters in instruction que for ( int i = 0; i <= argCnt; i++ ) { AddMachineInst( instructionPhase, opParams[ i ].Arg ); // destination parameter has no mask since it is the alpha channel // don't push mask for parrameter 0 (dst) if ( i > 0 ) { AddMachineInst( instructionPhase, (int)opParams[ i ].MaskRep ); } AddMachineInst( instructionPhase, opParams[ i ].Mod ); // check if source register read is valid in this phase passed &= IsRegisterReadValid( instructionPhase, i ); } UpdateRegisterWriteState( instructionPhase ); } // instruction passed on to machine instruction so clear the pipe ClearMachineInstState(); return passed; }
void AddMachineInst( PhaseType phase, int inst ) { switch ( phase ) { case PhaseType.PHASE1TEX: phase1TEX_mi.Add( inst ); break; case PhaseType.PHASE1ALU: phase1ALU_mi.Add( inst ); break; case PhaseType.PHASE2TEX: phase2TEX_mi.Add( inst ); break; case PhaseType.PHASE2ALU: phase2ALU_mi.Add( inst ); break; } // end switch(phase) }
public ITextBuilder Phase(PhaseType phase, string text) { return Phase(phase, text, LimitType.None); }
public EvalContext(ContextType context, PhaseType phase) { this.Phase = phase; this.Context = context; }
public EvalContext() { _phase = PhaseType.NONE; _context = ContextType.NONE; }
void SwitchLevel() { int newEnergy = m_player.Level; if (m_energy != newEnergy) { if (m_energy >= 0) { levels[m_energy].Deactivate(); Camera.main.GetComponent<Animation>().Play("CameraAnimation"); } levels[newEnergy].Activate(); levels[newEnergy].gameObject.SetActive(true); foreach (CustomObject x in m_objects) if (x != null) { x.gameObject.SetActive(x.Level == newEnergy); } m_energy = newEnergy; TurnDuration = levels[newEnergy].MovePhaseDuration; m_pauseTime = levels[newEnergy].SelectionPhaseDuration; m_phaseType = levels[newEnergy].SelectionPhaseType; Camera.main.GetComponent<CameraControls>().ForceSetPosition(m_player.transform.position); } }
public Phase(Phase p) { Name = p.Name; Channels = p.Channels; Times = p.Times; PType = p.PType; }
void UpdateRegisterWriteState( PhaseType phase ) { int reg_offset = opParams[ 0 ].Arg - Gl.GL_REG_0_ATI; switch ( phase ) { case PhaseType.PHASE1TEX: case PhaseType.PHASE1ALU: Phase_RegisterUsage[ reg_offset ].Phase1Write = true; break; case PhaseType.PHASE2TEX: case PhaseType.PHASE2ALU: Phase_RegisterUsage[ reg_offset ].Phase2Write = true; break; } // end switch(phase) }
bool IsRegisterReadValid( PhaseType phase, int param ) { bool passed = true; // assume everything will go alright // if in phase 2 ALU and argument is a source if ( ( phase == PhaseType.PHASE2ALU ) && ( param > 0 ) ) { // is source argument a temp register r0 - r5? if ( ( opParams[ param ].Arg >= Gl.GL_REG_0_ATI ) && ( opParams[ param ].Arg <= Gl.GL_REG_5_ATI ) ) { int reg_offset = opParams[ param ].Arg - Gl.GL_REG_0_ATI; // if register was not written to in phase 2 but was in phase 1 if ( ( Phase_RegisterUsage[ reg_offset ].Phase2Write == false ) && Phase_RegisterUsage[ reg_offset ].Phase1Write ) { // only perform register pass if there are ALU instructions in phase 1 if ( phase1ALU_mi.Count > 0 ) { // build machine instructions for passing a register from phase 1 to phase 2 // NB: only rgb components of register will get passed AddMachineInst( PhaseType.PHASE2TEX, (int)MachineInstruction.PassTexCoord ); AddMachineInst( PhaseType.PHASE2TEX, opParams[ param ].Arg ); // dst AddMachineInst( PhaseType.PHASE2TEX, opParams[ param ].Arg ); // coord AddMachineInst( PhaseType.PHASE2TEX, Gl.GL_SWIZZLE_STR_ATI ); // swizzle // mark register as being written to Phase_RegisterUsage[ reg_offset ].Phase2Write = true; } } // register can not be used because it has not been written to previously else { passed = false; } } } return passed; }
/** attempt to build a machine instruction using current tokens determines what phase machine insturction should be in and if an Alpha Op is required calls expandMachineInstruction() to expand the token into machine instructions */ bool BuildMachineInst() { // check the states to see if a machine instruction can be assembled // // assume everything will go okay untill proven otherwise bool passed = true; // start with machine NOP instuction // this is used after the switch to see if an instruction was set up // determine which MachineInstID is required based on the op instruction opType = MachineInstruction.Nop; switch ( (Symbol)opInst ) { // ALU operations case Symbol.ADD: case Symbol.SUB: case Symbol.MUL: case Symbol.MAD: case Symbol.LRP: case Symbol.MOV: case Symbol.CMP: case Symbol.CND: case Symbol.DP2ADD: case Symbol.DP3: case Symbol.DP4: opType = (MachineInstruction)( (int)MachineInstruction.ColorOp1 + argCnt - 1 ); // if context is ps.1.x and Macro not on or a phase marker was found then put all ALU ops in phase 2 ALU container if ( ( ( ( activeContexts & (uint)ContextKeyPattern.PS_1_1 ) > 0 ) && !macroOn ) || phaseMarkerFound ) { instructionPhase = PhaseType.PHASE2ALU; } else { instructionPhase = PhaseType.PHASE1ALU; } // check for alpha op in destination register which is OpParrams[0] // if no Mask for destination then make it .rgba if ( opParams[ 0 ].MaskRep == 0 ) { opParams[ 0 ].MaskRep = Gl.GL_RED_BIT_ATI | Gl.GL_GREEN_BIT_ATI | Gl.GL_BLUE_BIT_ATI | ALPHA_BIT; } if ( ( opParams[ 0 ].MaskRep & ALPHA_BIT ) > 0 ) { do_Alpha = true; opParams[ 0 ].MaskRep -= ALPHA_BIT; if ( opParams[ 0 ].MaskRep == 0 ) { opType = MachineInstruction.Nop; // only do alpha op } } break; case Symbol.TEXCRD: opType = MachineInstruction.PassTexCoord; if ( phaseMarkerFound ) { instructionPhase = PhaseType.PHASE2TEX; } else { instructionPhase = PhaseType.PHASE1TEX; } break; case Symbol.TEXLD: opType = MachineInstruction.SampleMap; if ( phaseMarkerFound ) { instructionPhase = PhaseType.PHASE2TEX; } else { instructionPhase = PhaseType.PHASE1TEX; } break; case Symbol.TEX: // PS_1_1 emulation opType = MachineInstruction.Tex; instructionPhase = PhaseType.PHASE1TEX; break; case Symbol.TEXCOORD: // PS_1_1 emulation opType = MachineInstruction.TexCoord; instructionPhase = PhaseType.PHASE1TEX; break; case Symbol.TEXREG2AR: passed = ExpandMacro( texreg2ar_MacroMods ); break; case Symbol.TEXREG2GB: passed = ExpandMacro( texreg2gb_MacroMods ); break; case Symbol.TEXDP3: passed = ExpandMacro( texdp3_MacroMods ); break; case Symbol.TEXDP3TEX: passed = ExpandMacro( texdp3tex_MacroMods ); break; case Symbol.TEXM3X2PAD: passed = ExpandMacro( texm3x2pad_MacroMods ); break; case Symbol.TEXM3X2TEX: passed = ExpandMacro( texm3x2tex_MacroMods ); break; case Symbol.TEXM3X3PAD: // only 2 texm3x3pad instructions allowed // use count to modify macro to select which mask to use if ( texm3x3padCount < 2 ) { texm3x3pad[ 4 ].ID = (Symbol)( (int)Symbol.R + texm3x3padCount ); texm3x3padCount++; passed = ExpandMacro( texm3x3pad_MacroMods ); } else { passed = false; } break; case Symbol.TEXM3X3TEX: passed = ExpandMacro( texm3x3tex_MacroMods ); break; case Symbol.DEF: opType = MachineInstruction.SetConstants; instructionPhase = PhaseType.PHASE1TEX; break; case Symbol.PHASE: // PS_1_4 only phaseMarkerFound = true; break; } // end of switch if ( passed ) { passed = ExpandMachineInstruction(); } return passed; }
private void OnNeighborRemove(Cube cube1, Cube.Side side1, Cube cube2, Cube.Side side2) { Log.Debug("Neighbor remove: {0}.{1} <-> {2}.{3}", cube1.UniqueId, side1, cube2.UniqueId, side2); CubeWrapper wrapper1 = (CubeWrapper)cube1.userData; CubeWrapper wrapper2 = (CubeWrapper)cube2.userData; if (wrapper1 != null && wrapper2 != null) { if (currentPhase == PhaseType.BEATSELECT2) { if ((wrapper1.mType == CubeType.SELECTOR && wrapper2.mType == CubeType.SELECTABLE) || (wrapper2.mType == CubeType.SELECTOR && wrapper1.mType == CubeType.SELECTABLE)) { currentPhase = PhaseType.BEATSELECT; readyToChangeState = true; } } } }
public ITextBuilder Phase(PhaseType phase, string text, LimitType limit) { this.abilities.Add(new Ability(AbilityType.Passive, phase, limit, text)); return this; }
public override void Tick() { ticks++; if (ticks > 9999 && ticksWaiting < ticks) { ticks = 0; } // if phase has been switched, perform behavior for updating to new phase if (readyToChangeState) { switch (currentPhase) { case (PhaseType.MODESELECT): break; case (PhaseType.NAMESELECT): currentVerseIndex = 0; readyToChangeState = false; fxMusic = Sounds.CreateSound("name"); if (mMusic.IsPlaying) { mMusic.SetVolume((float).5); } fxMusic.Play(1,1); mWrappers[0].mImage = "nameSelect"; mWrappers[0].mType = CubeType.SELECTABLE; mWrappers[0].mCubeName = CubeName.NAMES1; mWrappers[1].mImage = "nameSelect2"; mWrappers[1].mType = CubeType.SELECTABLE; mWrappers[1].mCubeName = CubeName.NAMES2; mWrappers[2].mImage = "selector"; mWrappers[2].mType = CubeType.SELECTOR; mWrappers[2].mCubeName = CubeName.SELECTOR; foreach (CubeWrapper wrapper in mWrappers) { wrapper.textOrImage = DisplayType.IMAGE; wrapper.DrawSlide(); } break; case (PhaseType.BEATSELECT): if (sampleMusic != null && sampleMusic.IsPlaying) sampleMusic.Stop(); mWrappers[0].mImage = "beatSelect"; mWrappers[0].mType = CubeType.SELECTABLE; mWrappers[0].mCubeName = CubeName.BEAT1; mWrappers[1].mImage = "beatSelect2"; mWrappers[1].mType = CubeType.SELECTABLE; mWrappers[1].mCubeName = CubeName.BEAT2; mWrappers[2].mImage = "selector"; mWrappers[2].mType = CubeType.SELECTOR; mWrappers[2].mCubeName = CubeName.SELECTOR; readyToChangeState = false; foreach (CubeWrapper wrapper in mWrappers) { wrapper.textOrImage = DisplayType.IMAGE; wrapper.DrawSlide(); } break; case (PhaseType.BEATSELECT2): foreach (CubeWrapper wrapper in mWrappers) { if (wrapper.mCubeName == CubeName.SELECTOR) { wrapper.mImage = "continue"; wrapper.DrawSlide(); } } readyToChangeState = false; break; case (PhaseType.THEMESELECT): mWrappers[0].mImage = "themeSelect"; mWrappers[0].mType = CubeType.SELECTABLE; mWrappers[0].mCubeName = CubeName.THEMES1; mWrappers[1].mImage = "themeSelect2"; mWrappers[1].mType = CubeType.SELECTABLE; mWrappers[1].mCubeName = CubeName.THEMES2; mWrappers[2].mImage = "selector"; mWrappers[2].mType = CubeType.SELECTOR; mWrappers[2].mCubeName = CubeName.SELECTOR; readyToChangeState = false; fxMusic = Sounds.CreateSound("theme"); fxMusic.Play(1, 1); foreach (CubeWrapper wrapper in mWrappers) { wrapper.DrawSlide(); } break; // do sound fx case (PhaseType.RAPSTART1): mWrappers[0].mImage = "dis"; mWrappers[0].mType = CubeType.NONE; mWrappers[0].mCubeName = CubeName.DIS; mWrappers[1].mImage = "dis"; mWrappers[1].mType = CubeType.NONE; mWrappers[1].mCubeName = CubeName.DIS; mWrappers[2].mImage = "continue"; mWrappers[2].mType = CubeType.NONE; mWrappers[2].mCubeName = CubeName.MIC; readyToChangeState = false; fxMusic = Sounds.CreateSound("micdis"); fxMusic.Play(1, 1); foreach (CubeWrapper wrapper in mWrappers) { wrapper.DrawSlide(); } verseLines = initializeVerseLines(); break; // do sound fx case (PhaseType.RAPSTART2): mWrappers[2].mImage = "3"; mWrappers[2].DrawSlide(); ticksWaiting = ticks + 20; readyToChangeState = true; currentPhase = PhaseType.RAPSTART3; break; // do sound fx case (PhaseType.RAPSTART3): if (ticks == ticksWaiting) { mWrappers[2].mImage = "2"; mWrappers[2].DrawSlide(); ticksWaiting = ticks + 20; readyToChangeState = true; currentPhase = PhaseType.RAPSTART4; } break; // do sound fx case (PhaseType.RAPSTART4): if (ticks == ticksWaiting) { mWrappers[2].mImage = "1"; mWrappers[2].DrawSlide(); ticksWaiting = ticks + 20; readyToChangeState = true; currentPhase = PhaseType.RAPSTART5; } break; // do sound fx case (PhaseType.RAPSTART5): if (ticks == ticksWaiting) { mWrappers[2].mImage = "go"; mWrappers[2].DrawSlide(); ticksWaiting = ticks + 20; readyToChangeState = true; currentPhase = PhaseType.LYRICS; } break; case (PhaseType.LYRICS): if (ticks == ticksWaiting) { mMusic.Play(1, -1); readyToChangeState = false; foreach (CubeWrapper wrapper in mWrappers) { wrapper.textOrImage = DisplayType.TEXT; string newText = verseLines[currentVerseIndex]; wrapper.mText.setText(newText); wrapper.DrawSlide(); } } break; case (PhaseType.DOUBLEDIS): foreach (CubeWrapper wrapper in mWrappers) { if ((wrapper.mCubeName == CubeName.JUSTDISSED) || (wrapper.mCubeName == CubeName.MIC)) { wrapper.mImage = "dis"; wrapper.textOrImage = DisplayType.IMAGE; } else if (wrapper.mCubeName == CubeName.DIS) { wrapper.mImage = "doubledis"; wrapper.textOrImage = DisplayType.IMAGE; } wrapper.DrawSlide(); } readyToChangeState = false; break; case (PhaseType.ENDOFRAP): mWrappers[0].mImage = "max"; mWrappers[1].mImage = "nice"; mWrappers[2].mImage = "continue"; foreach (CubeWrapper wrapper in mWrappers) { wrapper.textOrImage = DisplayType.IMAGE; wrapper.DrawSlide(); } readyToChangeState = false; break; case (PhaseType.TRIVIA1): fxMusic = Sounds.CreateSound("trivia"); fxMusic.Play(1, 1); foreach (CubeWrapper wrapper in mWrappers) { if (wrapper.mCubeName == CubeName.MIC) { wrapper.mCubeName = CubeName.DEFENDER; wrapper.textOrImage = DisplayType.IMAGE; wrapper.mImage = "buzzwer"; } else if (wrapper.mCubeName == CubeName.JUSTDISSED) { wrapper.mCubeName = CubeName.CHALLENGER; wrapper.textOrImage = DisplayType.IMAGE; wrapper.mImage = "buzzwer"; } else if (wrapper.mCubeName == CubeName.DIS) { wrapper.mCubeName = CubeName.QUESTION; wrapper.textOrImage = DisplayType.TEXT; wrapper.mText.setText(triviaQuestions[triviaIndex]); } wrapper.DrawSlide(); readyToChangeState = false; } break; case (PhaseType.TRIVIA2): foreach (CubeWrapper wrapper in mWrappers) { if (wrapper.mCubeName == buzzer) { wrapper.mImage = "buzzerWin"; } else if (wrapper.mCubeName == CubeName.QUESTION) { wrapper.mCubeName = CubeName.ANSWER; wrapper.mText.setText(triviaAnswers[triviaIndex]); } else { // must be the one that didn't buzz in wrapper.mImage = "buzzerLose"; } readyToChangeState = false; wrapper.DrawSlide(); } triviaIndex++; break; case (PhaseType.TRIVIA3): foreach (CubeWrapper wrapper in mWrappers) { if (wrapper.mCubeName == CubeName.ANSWER) { wrapper.textOrImage = DisplayType.IMAGE; wrapper.mImage = "pressorshake"; wrapper.DrawSlide(); readyToChangeState = false; } } break; case (PhaseType.SCORES): mWrappers[0].textOrImage = DisplayType.TEXT; mWrappers[1].textOrImage = DisplayType.TEXT; mWrappers[2].textOrImage = DisplayType.IMAGE; mWrappers[2].mImage = "continue"; mWrappers[2].DrawSlide(); string scoreText = makeScoreString(); mWrappers[1].mText.setText(scoreText); mWrappers[0].mText.setText("LOOK AT,YOUR SCORE"); mWrappers[0].DrawSlide(); mWrappers[1].DrawSlide(); break; default: break; } } else if (ticks == ticksWaiting) { switch (currentPhase) { case (PhaseType.DOUBLEDIS): currentPhase = PhaseType.TRIVIA1; readyToChangeState = true; break; // add in the RapStart part default: break; } } }