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;
}
}
}
