public void StartPattern(int moveCount, float patternLengthTime)
{
lengthTime = patternLengthTime;
GenerateNewPattern(moveCount);
patternState = PatternState.OTHERS_DO_MOVES;
RestartPattern();
}
protected override bool OnExecute(PatternState state)
{
state.End(Destination);
return(true);
}
public void StopPattern()
{
patternState = PatternState.FINISHED;
}
private void PatternComplete()
{
patternState = PatternState.FINISHED;
if (OnPatternComplete != null)
OnPatternComplete();
}
private void OnBackSlash() {
if (InEscapeSequence) {
AppendEscapedChar('\\');
} else {
_state |= PatternState.InEscapeSequence;
}
}
private void OnCloseBracket() {
if (InEscapeSequence) {
AppendEscapedChar(']');
} else {
_sb.Append(']');
_state &= ~PatternState.InCharacterClass;
}
}
private void EvalGroupState(char token, bool escaped)
{
if (!escaped)
{
if (patternState != PatternState.StartCharacterClass && patternState != PatternState.CharacterClass)
{
switch (token)
{
case '(':
previousPatternState = patternState;
patternState = PatternState.StartGroup;
previousStartGroupIndex = startGroupIndex;
startGroupIndex = currentIndex;
groupLevel++;
if (previousPatternState == PatternState.StartGroup) // ((
{
NumberedCaptureGroupFound(previousStartGroupIndex, currentIndex);
}
return;
case ')':
groupLevel--;
return;
default:
//see switch below
break;
}
}
switch (patternState)
{
case PatternState.Other: // Pattern, Modifiers
switch (token)
{
case '[':
patternState = PatternState.StartCharacterClass;
break;
}
break;
case PatternState.StartCharacterClass:
if (token != '^') patternState = PatternState.CharacterClass;
break;
case PatternState.CharacterClass:
if (token == ']') patternState = PatternState.Other;
break;
case PatternState.StartGroup: // (
if (token == '?')
{
patternState = PatternState.StartExtendedGroup;
}
else
{
if (previousPatternState == PatternState.StartExtendedGroup)
{
ConditionFound(currentIndex);
}
else
{
NumberedCaptureGroupFound(startGroupIndex, currentIndex);
}
patternState = token == '[' ? PatternState.StartCharacterClass : PatternState.Other;
}
break;
case PatternState.StartExtendedGroup: // (?
// NonCaptureGroup: // (?: -> Other
switch (token)
{
case '\'':
patternState = PatternState.NamedCaptureGroupQuote;
startNamedIndex = currentIndex + 1;
break;
case '<':
patternState = PatternState.StartNamedCaptureGroupAngleBracket;
startNamedIndex = currentIndex + 1;
break;
default:
patternState = PatternState.Other;
break;
}
break;
case PatternState.NamedCaptureGroupQuote: // (?'
if (token == '\'')
{
NamedCaptureGroupFound(startGroupIndex, currentIndex + 1, GetName(startNamedIndex, currentIndex));
patternState = PatternState.Other;
} //else we are inside the name
break;
case PatternState.StartNamedCaptureGroupAngleBracket: // (?<
// PositiveLookBehind: // (?<= -> Other
// NegativeLookBehind: // (?<! -> Other
if (token == '=' || token == '!')
{
patternState = PatternState.Other;
}
else
{
patternState = PatternState.NamedCaptureGroupAngleBracket;
}
break;
case PatternState.NamedCaptureGroupAngleBracket:
if (token == '>')
{
NamedCaptureGroupFound(startGroupIndex, currentIndex + 1, GetName(startNamedIndex, currentIndex));
patternState = PatternState.Other;
} //else we are inside the name
break;
default:
throw new NotSupportedException("Unknown group state");
}
}
else
{
switch (patternState)
{
case PatternState.StartCharacterClass:
patternState = PatternState.CharacterClass;
break;
case PatternState.StartExtendedGroup:
patternState = PatternState.Other;
break;
case PatternState.StartGroup:
if (previousPatternState == PatternState.StartExtendedGroup)
{
ConditionFound(currentIndex-1);
}
else
{
NumberedCaptureGroupFound(startGroupIndex, currentIndex-1);
}
patternState = PatternState.Other;
break;
case PatternState.StartNamedCaptureGroupAngleBracket:
patternState = PatternState.NamedCaptureGroupAngleBracket;
break;
}
}
}
protected override bool OnCanExecute(PatternState state)
{
return(state.Enumerator.HasCurrent &&
state.Enumerator.Current.Type == Type &&
state.Enumerator.Current.Content == Content);
}
protected override void createPattern()
{
PatternPackage newPs = null;
PatternState newPattern;
newPattern = new PatternState();
newPattern.setPattern
(
true, // bool || isMix || 패턴을 다른 패턴과 조합해서 쓸것인지
PATTERN_NAME.CIRCULAR, // enum || PatternName || 무슨 패턴을 쓸건지?
0.9f, // float || XScale || X Scale 값 조정.
0.9f, // flaot || YScale || Y Scale 값 조정.
3.0f, // float || Speed || 탄환이 나갈 때 첫 속도
0.0f, // float || Angle || 탄환 첫 발사 각도
0.0f, // float || SpeedRate || 탄환이 나갈 때 첫 속도를 점점 올릴것인지?
0.0f, // float || AngleRate || 탄환이 나갈 때 발사 각도를 점점 올릴것인지? 샷건이나 부채꼬에서는 각도를 각 각도
1.5f, // float || Interval || 탄환 사이의 간격 (시간)
0.0f, // float || BulletSpeedRate || 탄환이 가속도
10.0f, // float || BulletAngleRate || 탄환의 각 증가속도?? 알아서 탄환의 각이 커짐.
8, // int || Count || 탄환을 한번에 발사 하는 놈의 수를 조정. ShotGun은 한개 넘게
0.0f, // float || MinInterval || ShotGun ,Direct 패턴에서 탄환의 그룹안의 탄환간의 간격
0.0f, // float || RotateAngle || 거의 쓸일은 없겠지만, 회전 각 정하기? Washer에서 주로 쓰임.
0.00f, // float || RotateAngleRate || 탄환이 회전 하는 패턴을 가질 경우, 회전 각 속도 조정 Rotate 붙은 패턴에서 쓰임.
0.0f, // float || MaxAngle || Washer 회전 패턴의 경우, 최대 돌 각도가 어느정도인지?
0, // int || GroupCount || ShotGun Pattern에서만 쓰임. Shot Group 수 결정. 0으로 둬도 무방.
BULLET_TYPE.STOP_AND_PLAY, // enum || BulletType || 탄막의 종류는? 안쓰면 Blue값이 Default
BULLET_IMAGE.BASE_BULLET4_1, // enum || BulletImage || 탄막의 이미지 타입은?
0.0f, // float || HomingRate || 유도탄의 유도정도, 유도탄 안쓰면 0.0f
false, // bool || isHoming || 유도탄으로 발사할건가?
0.25f, // float || MoveTime || 탄환을 처음 어느 정도 움직일 것인가>
1.2f // float || StopTime || 탄환을 어느 정도 멈추고 다시 진행할 것인가)
);
newPs = new PatternPackage(newPattern, "B_SBrown", "E_6", "E_6", "M_5", m_moveList[3]);
m_curPatternList.Add(newPs);
newPattern = new PatternState();
newPattern.setPattern
(
true, // bool || isMix || 패턴을 다른 패턴과 조합해서 쓸것인지
PATTERN_NAME.CIRCULAR, // enum || PatternName || 무슨 패턴을 쓸건지?
0.9f, // float || XScale || X Scale 값 조정.
0.9f, // flaot || YScale || Y Scale 값 조정.
3.0f, // float || Speed || 탄환이 나갈 때 첫 속도
18.0f, // float || Angle || 탄환 첫 발사 각도
0.0f, // float || SpeedRate || 탄환이 나갈 때 첫 속도를 점점 올릴것인지?
0.0f, // float || AngleRate || 탄환이 나갈 때 발사 각도를 점점 올릴것인지? 샷건이나 부채꼬에서는 각도를 각 각도
1.6f, // float || Interval || 탄환 사이의 간격 (시간)
0.0f, // float || BulletSpeedRate || 탄환이 가속도
10.0f, // float || BulletAngleRate || 탄환의 각 증가속도?? 알아서 탄환의 각이 커짐.
8, // int || Count || 탄환을 한번에 발사 하는 놈의 수를 조정. ShotGun은 한개 넘게
0.0f, // float || MinInterval || ShotGun ,Direct 패턴에서 탄환의 그룹안의 탄환간의 간격
0.0f, // float || RotateAngle || 거의 쓸일은 없겠지만, 회전 각 정하기? Washer에서 주로 쓰임.
0.00f, // float || RotateAngleRate || 탄환이 회전 하는 패턴을 가질 경우, 회전 각 속도 조정 Rotate 붙은 패턴에서 쓰임.
0.0f, // float || MaxAngle || Washer 회전 패턴의 경우, 최대 돌 각도가 어느정도인지?
0, // int || GroupCount || ShotGun Pattern에서만 쓰임. Shot Group 수 결정. 0으로 둬도 무방.
BULLET_TYPE.STOP_AND_PLAY, // enum || BulletType || 탄막의 종류는? 안쓰면 Blue값이 Default
BULLET_IMAGE.BASE_BULLET4_1, // enum || BulletImage || 탄막의 이미지 타입은?
0.0f, // float || HomingRate || 유도탄의 유도정도, 유도탄 안쓰면 0.0f
false, // bool || isHoming || 유도탄으로 발사할건가?
0.35f, // float || MoveTime || 탄환을 처음 어느 정도 움직일 것인가>
1.1f // float || StopTime || 탄환을 어느 정도 멈추고 다시 진행할 것인가)
);
newPs = new PatternPackage(newPattern, "B_SBrown", "E_6", "E_6", "M_5", m_moveList[3]);
m_curPatternList.Add(newPs);
newPattern = new PatternState();
newPattern.setPattern
(
false, // bool || isMix || 패턴을 다른 패턴과 조합해서 쓸것인지
PATTERN_NAME.ROTATE_CIRCULAR, // enum || PatternName || 무슨 패턴을 쓸건지?
0.5f, // float || XScale || X Scale 값 조정.
0.5f, // flaot || YScale || Y Scale 값 조정.
0.0f, // float || Speed || 탄환이 나갈 때 첫 속도
0.0f, // float || Angle || 탄환 첫 발사 각도
0.0f, // float || SpeedRate || 탄환이 나갈 때 첫 속도를 점점 올릴것인지?
20.0f, // float || AngleRate || 탄환이 나갈 때 발사 각도를 점점 올릴것인지? 샷건이나 부채꼬에서는 각도를 각 각도
0.08f, // float || Interval || 탄환 사이의 간격 (시간)
3.5f, // float || BulletSpeedRate || 탄환이 가속도
0.0f, // float || BulletAngleRate || 탄환의 각 증가속도?? 알아서 탄환의 각이 커짐.
6, // int || Count || 탄환을 한번에 발사 하는 놈의 수를 조정.
0.1f, // float || MinInterval || ShotGun ,Direct 패턴에서 탄환의 그룹안의 탄환간의 간격
0.0f, // float || RotateAngle || 거의 쓸일은 없겠지만, 회전 각 정하기? Washer에서 주로 쓰임.
2.00f, // float || RotateAngleRate || 탄환이 회전 하는 패턴을 가질 경우, 회전 각 속도 조정 Rotate 붙은 패턴에서 쓰임.
0.0f, // float || MaxAngle || Washer 회전 패턴의 경우, 최대 돌 각도가 어느정도인지?
0, // int || GroupCount || ShotGun Pattern에서만 쓰임. Shot Group 수 결정. 0으로 둬도 무방.
BULLET_TYPE.BASE, // enum || BulletType || 탄막의 종류는? 안쓰면 Blue값이 Default
BULLET_IMAGE.BASE_BULLET4_3, // enum || BulletImage || 탄막의 이미지 타입은?
0.0f, // float || HomingRate || 유도탄의 유도정도, 유도탄 안쓰면 0.0f
false, // bool || isHoming || 유도탄으로 발사할건가?
0.0f, // float || MoveTime || 탄환을 처음 어느 정도 움직일 것인가>
0.0f // float || StopTime || 탄환을 어느 정도 멈추고 다시 진행할 것인가)
);
newPs = new PatternPackage(newPattern, "B_SBrown", "E_6", "E_6", "M_5", m_moveList[3]);
m_curPatternList.Add(newPs);
///////////////////////////////////////////////////////////////////////
// 페이즈 2
////////////////////////////////////////////////////////////////////////
for (int i = 0; i < 3; i++)
{
newPattern = new PatternState();
newPattern.setPattern
(
true, // bool || isMix || 패턴을 다른 패턴과 조합해서 쓸것인지
PATTERN_NAME.AIMING_DIRECT, // enum || PatternName || 무슨 패턴을 쓸건지?
2.5f, // float || XScale || X Scale 값 조정.
2.5f, // flaot || YScale || Y Scale 값 조정.
3.5f, // float || Speed || 탄환이 나갈 때 첫 속도
0.0f, // float || Angle || 탄환 첫 발사 각도
00.0f, // float || SpeedRate || 탄환이 나갈 때 첫 속도를 점점 올릴것인지?
0.0f, // float || AngleRate || 탄환이 나갈 때 발사 각도를 점점 올릴것인지? 샷건이나 부채꼬에서는 각도를 각 각도
3.0f, // float || Interval || 탄환 사이의 간격 (시간)
0.0f, // float || BulletSpeedRate || 탄환이 가속도
0.0f, // float || BulletAngleRate || 탄환의 각 증가속도?? 알아서 탄환의 각이 커짐.
1, // int || Count || 탄환을 한번에 발사 하는 놈의 수를 조정.
0.0f, // float || MinInterval || ShotGun ,Direct 패턴에서 탄환의 그룹안의 탄환간의 간격
0.0f, // float || RotateAngle || 거의 쓸일은 없겠지만, 회전 각 정하기? Washer에서 주로 쓰임.
0.00f, // float || RotateAngleRate || 탄환이 회전 하는 패턴을 가질 경우, 회전 각 속도 조정 Rotate 붙은 패턴에서 쓰임.
0.0f, // float || MaxAngle || Washer 회전 패턴의 경우, 최대 돌 각도가 어느정도인지?
0, // int || GroupCount || ShotGun Pattern에서만 쓰임. Shot Group 수 결정. 0으로 둬도 무방.
BULLET_TYPE.BASE, // enum || BulletType || 탄막의 종류는? 안쓰면 Blue값이 Default
BULLET_IMAGE.BASE_BULLET4_3, // enum || BulletImage || 탄막의 이미지 타입은?
0.0f, // float || HomingRate || 유도탄의 유도정도, 유도탄 안쓰면 0.0f
false // bool || isHoming || 유도탄으로 발사할건가?
);
newPs = new PatternPackage(newPattern, "B_SBrown", "E_6", "E_6", "M_5", m_moveList[2]);
newPs.m_PPDelay = 1.2f * i;
m_curPatternList.Add(newPs);
}
for (int i = 0; i < 3; i++)
{
newPattern = new PatternState();
newPattern.setPattern
(
true, // bool || isMix || 패턴을 다른 패턴과 조합해서 쓸것인지
PATTERN_NAME.AIMING_DIRECT, // enum || PatternName || 무슨 패턴을 쓸건지?
3.2f, // float || XScale || X Scale 값 조정.
3.2f, // flaot || YScale || Y Scale 값 조정.
3f, // float || Speed || 탄환이 나갈 때 첫 속도
0.0f, // float || Angle || 탄환 첫 발사 각도
00.0f, // float || SpeedRate || 탄환이 나갈 때 첫 속도를 점점 올릴것인지?
0.0f, // float || AngleRate || 탄환이 나갈 때 발사 각도를 점점 올릴것인지? 샷건이나 부채꼬에서는 각도를 각 각도
3.0f, // float || Interval || 탄환 사이의 간격 (시간)
0.0f, // float || BulletSpeedRate || 탄환이 가속도
0.0f, // float || BulletAngleRate || 탄환의 각 증가속도?? 알아서 탄환의 각이 커짐.
1, // int || Count || 탄환을 한번에 발사 하는 놈의 수를 조정.
0.0f, // float || MinInterval || ShotGun ,Direct 패턴에서 탄환의 그룹안의 탄환간의 간격
0.0f, // float || RotateAngle || 거의 쓸일은 없겠지만, 회전 각 정하기? Washer에서 주로 쓰임.
0.00f, // float || RotateAngleRate || 탄환이 회전 하는 패턴을 가질 경우, 회전 각 속도 조정 Rotate 붙은 패턴에서 쓰임.
0.0f, // float || MaxAngle || Washer 회전 패턴의 경우, 최대 돌 각도가 어느정도인지?
0, // int || GroupCount || ShotGun Pattern에서만 쓰임. Shot Group 수 결정. 0으로 둬도 무방.
BULLET_TYPE.BASE, // enum || BulletType || 탄막의 종류는? 안쓰면 Blue값이 Default
BULLET_IMAGE.BASE_BULLET4_3, // enum || BulletImage || 탄막의 이미지 타입은?
0.0f, // float || HomingRate || 유도탄의 유도정도, 유도탄 안쓰면 0.0f
false // bool || isHoming || 유도탄으로 발사할건가?
);
newPs = new PatternPackage(newPattern, "B_SBrown", "E_6", "E_6", "M_5", m_moveList[2]);
newPs.m_PPDelay = 0.7f * i;
m_curPatternList.Add(newPs);
}
newPattern = new PatternState();
newPattern.setPattern
(
false, // bool || isMix || 패턴을 다른 패턴과 조합해서 쓸것인지
PATTERN_NAME.AIMING_DIRECT, // enum || PatternName || 무슨 패턴을 쓸건지?
4.2f, // float || XScale || X Scale 값 조정.
4.2f, // flaot || YScale || Y Scale 값 조정.
1.8f, // float || Speed || 탄환이 나갈 때 첫 속도
0.0f, // float || Angle || 탄환 첫 발사 각도
00.0f, // float || SpeedRate || 탄환이 나갈 때 첫 속도를 점점 올릴것인지?
0.0f, // float || AngleRate || 탄환이 나갈 때 발사 각도를 점점 올릴것인지? 샷건이나 부채꼬에서는 각도를 각 각도
2.1f, // float || Interval || 탄환 사이의 간격 (시간)
0.0f, // float || BulletSpeedRate || 탄환이 가속도
0.0f, // float || BulletAngleRate || 탄환의 각 증가속도?? 알아서 탄환의 각이 커짐.
1, // int || Count || 탄환을 한번에 발사 하는 놈의 수를 조정.
0.0f, // float || MinInterval || ShotGun ,Direct 패턴에서 탄환의 그룹안의 탄환간의 간격
0.0f, // float || RotateAngle || 거의 쓸일은 없겠지만, 회전 각 정하기? Washer에서 주로 쓰임.
0.00f, // float || RotateAngleRate || 탄환이 회전 하는 패턴을 가질 경우, 회전 각 속도 조정 Rotate 붙은 패턴에서 쓰임.
0.0f, // float || MaxAngle || Washer 회전 패턴의 경우, 최대 돌 각도가 어느정도인지?
0, // int || GroupCount || ShotGun Pattern에서만 쓰임. Shot Group 수 결정. 0으로 둬도 무방.
BULLET_TYPE.BASE, // enum || BulletType || 탄막의 종류는? 안쓰면 Blue값이 Default
BULLET_IMAGE.BASE_BULLET4_3, // enum || BulletImage || 탄막의 이미지 타입은?
0.0f, // float || HomingRate || 유도탄의 유도정도, 유도탄 안쓰면 0.0f
false // bool || isHoming || 유도탄으로 발사할건가?
);
newPs = new PatternPackage(newPattern, "B_SBrown", "E_6", "E_6", "M_5", m_moveList[2]);
newPs.m_PPDelay = 2.1f;
m_curPatternList.Add(newPs);
///////////////////////////////////////////////////////////////////////
// 페이즈 3
////////////////////////////////////////////////////////////////////////
for (int i = 0; i < 10; i++)
{
newPattern = new PatternState();
newPattern.setPattern
(
true, // bool || isMix || 패턴을 다른 패턴과 조합해서 쓸것인지
PATTERN_NAME.AIMING_DIRECT, // enum || PatternName || 무슨 패턴을 쓸건지?
0.6f, // float || XScale || X Scale 값 조정.
0.6f, // flaot || YScale || Y Scale 값 조정.
2.0f, // float || Speed || 탄환이 나갈 때 첫 속도
0.0f, // float || Angle || 탄환 첫 발사 각도
00.0f, // float || SpeedRate || 탄환이 나갈 때 첫 속도를 점점 올릴것인지?
0.0f, // float || AngleRate || 탄환이 나갈 때 발사 각도를 점점 올릴것인지? 샷건이나 부채꼬에서는 각도를 각 각도
4.0f, // float || Interval || 탄환 사이의 간격 (시간)
0.0f, // float || BulletSpeedRate || 탄환이 가속도
0.0f, // float || BulletAngleRate || 탄환의 각 증가속도?? 알아서 탄환의 각이 커짐.
1, // int || Count || 탄환을 한번에 발사 하는 놈의 수를 조정.
0.0f, // float || MinInterval || ShotGun ,Direct 패턴에서 탄환의 그룹안의 탄환간의 간격
0.0f, // float || RotateAngle || 거의 쓸일은 없겠지만, 회전 각 정하기? Washer에서 주로 쓰임.
0.00f, // float || RotateAngleRate || 탄환이 회전 하는 패턴을 가질 경우, 회전 각 속도 조정 Rotate 붙은 패턴에서 쓰임.
0.0f, // float || MaxAngle || Washer 회전 패턴의 경우, 최대 돌 각도가 어느정도인지?
0, // int || GroupCount || ShotGun Pattern에서만 쓰임. Shot Group 수 결정. 0으로 둬도 무방.
BULLET_TYPE.STOP_AND_PLAY, // enum || BulletType || 탄막의 종류는? 안쓰면 Blue값이 Default
BULLET_IMAGE.BASE_BULLET4_3, // enum || BulletImage || 탄막의 이미지 타입은?
0.0f, // float || HomingRate || 유도탄의 유도정도, 유도탄 안쓰면 0.0f
false, // bool || isHoming || 유도탄으로 발사할건가?
0.0f,
2.0f,
true,
0.0f + Mathf.Cos((36.0f * i) * Mathf.Deg2Rad) * 0.8f,
0.0f + Mathf.Sin((36.0f * i) * Mathf.Deg2Rad) * 0.8f
);
newPs = new PatternPackage(newPattern, "B_SBrown", "E_6", "E_6", "M_5", m_moveList[4]);
m_curPatternList.Add(newPs);
}
for (int i = 0; i < 11; i++)
{
newPattern = new PatternState();
newPattern.setPattern
(
true, // bool || isMix || 패턴을 다른 패턴과 조합해서 쓸것인지
PATTERN_NAME.DIRECT, // enum || PatternName || 무슨 패턴을 쓸건지?
0.6f, // float || XScale || X Scale 값 조정.
0.6f, // flaot || YScale || Y Scale 값 조정.
2.0f, // float || Speed || 탄환이 나갈 때 첫 속도
0.0f, // float || Angle || 탄환 첫 발사 각도
00.0f, // float || SpeedRate || 탄환이 나갈 때 첫 속도를 점점 올릴것인지?
0.0f, // float || AngleRate || 탄환이 나갈 때 발사 각도를 점점 올릴것인지? 샷건이나 부채꼬에서는 각도를 각 각도
Random.Range(0.9f, 1.0f), // float || Interval || 탄환 사이의 간격 (시간)
0.0f, // float || BulletSpeedRate || 탄환이 가속도
0.0f, // float || BulletAngleRate || 탄환의 각 증가속도?? 알아서 탄환의 각이 커짐.
1, // int || Count || 탄환을 한번에 발사 하는 놈의 수를 조정.
0.0f, // float || MinInterval || ShotGun ,Direct 패턴에서 탄환의 그룹안의 탄환간의 간격
0.0f, // float || RotateAngle || 거의 쓸일은 없겠지만, 회전 각 정하기? Washer에서 주로 쓰임.
0.00f, // float || RotateAngleRate || 탄환이 회전 하는 패턴을 가질 경우, 회전 각 속도 조정 Rotate 붙은 패턴에서 쓰임.
0.0f, // float || MaxAngle || Washer 회전 패턴의 경우, 최대 돌 각도가 어느정도인지?
3, // int || GroupCount || ShotGun Pattern에서만 쓰임. Shot Group 수 결정. 0으로 둬도 무방.
BULLET_TYPE.BASE, // enum || BulletType || 탄막의 종류는? 안쓰면 Blue값이 Default
BULLET_IMAGE.BASE_BULLET4_2, // enum || BulletImage || 탄막의 이미지 타입은?
0.0f, // float || HomingRate || 유도탄의 유도정도, 유도탄 안쓰면 0.0f
false, // bool || isHoming || 유도탄으로 발사할건가?
0.0f,
0.0f,
false,
-3.0f,
-4.70f + (0.9f * i)
);
newPs = new PatternPackage(newPattern, "B_SBrown", "E_6", "E_6", "M_5", m_moveList[4]);
m_curPatternList.Add(newPs);
}
for (int i = 0; i < 11; i++)
{
newPattern = new PatternState();
newPattern.setPattern
(
true, // bool || isMix || 패턴을 다른 패턴과 조합해서 쓸것인지
PATTERN_NAME.DIRECT, // enum || PatternName || 무슨 패턴을 쓸건지?
0.7f, // float || XScale || X Scale 값 조정.
0.7f, // flaot || YScale || Y Scale 값 조정.
1.0f, // float || Speed || 탄환이 나갈 때 첫 속도
180.0f, // float || Angle || 탄환 첫 발사 각도
00.0f, // float || SpeedRate || 탄환이 나갈 때 첫 속도를 점점 올릴것인지?
0.0f, // float || AngleRate || 탄환이 나갈 때 발사 각도를 점점 올릴것인지? 샷건이나 부채꼬에서는 각도를 각 각도
Random.Range(1.2f, 1.3f), // float || Interval || 탄환 사이의 간격 (시간)
0.0f, // float || BulletSpeedRate || 탄환이 가속도
0.0f, // float || BulletAngleRate || 탄환의 각 증가속도?? 알아서 탄환의 각이 커짐.
1, // int || Count || 탄환을 한번에 발사 하는 놈의 수를 조정.
0.3f, // float || MinInterval || ShotGun ,Direct 패턴에서 탄환의 그룹안의 탄환간의 간격
0.0f, // float || RotateAngle || 거의 쓸일은 없겠지만, 회전 각 정하기? Washer에서 주로 쓰임.
0.00f, // float || RotateAngleRate || 탄환이 회전 하는 패턴을 가질 경우, 회전 각 속도 조정 Rotate 붙은 패턴에서 쓰임.
0.0f, // float || MaxAngle || Washer 회전 패턴의 경우, 최대 돌 각도가 어느정도인지?
3, // int || GroupCount || ShotGun Pattern에서만 쓰임. Shot Group 수 결정. 0으로 둬도 무방.
BULLET_TYPE.STOP_AND_PLAY, // enum || BulletType || 탄막의 종류는? 안쓰면 Blue값이 Default
BULLET_IMAGE.BASE_BULLET4_1, // enum || BulletImage || 탄막의 이미지 타입은?
0.0f, // float || HomingRate || 유도탄의 유도정도, 유도탄 안쓰면 0.0f
false, // bool || isHoming || 유도탄으로 발사할건가?
0.0f,
0.0f,
false,
3.0f,
-4.2f + (0.9f * i)
);
newPs = new PatternPackage(newPattern, "B_SBrown", "E_6", "E_6", "M_5", m_moveList[4]);
m_curPatternList.Add(newPs);
}
}
private void EvalGroupState(char token, bool escaped)
{
if (!escaped)
{
if (patternState != PatternState.StartCharacterClass && patternState != PatternState.CharacterClass)
{
switch (token)
{
case '(':
previousPatternState = patternState;
patternState = PatternState.StartGroup;
previousStartGroupIndex = startGroupIndex;
startGroupIndex = currentIndex;
groupLevel++;
if (previousPatternState == PatternState.StartGroup) // ((
{
NumberedCaptureGroupFound(previousStartGroupIndex, currentIndex);
}
return;
case ')':
groupLevel--;
return;
default:
//see switch below
break;
}
}
switch (patternState)
{
case PatternState.Other: // Pattern, Modifiers
switch (token)
{
case '[':
patternState = PatternState.StartCharacterClass;
break;
}
break;
case PatternState.StartCharacterClass:
if (token != '^')
{
patternState = PatternState.CharacterClass;
}
break;
case PatternState.CharacterClass:
if (token == ']')
{
patternState = PatternState.Other;
}
break;
case PatternState.StartGroup: // (
if (token == '?')
{
patternState = PatternState.StartExtendedGroup;
}
else
{
if (previousPatternState == PatternState.StartExtendedGroup)
{
ConditionFound(currentIndex);
}
else
{
NumberedCaptureGroupFound(startGroupIndex, currentIndex);
}
patternState = token == '[' ? PatternState.StartCharacterClass : PatternState.Other;
}
break;
case PatternState.StartExtendedGroup: // (?
// NonCaptureGroup: // (?: -> Other
switch (token)
{
case '\'':
patternState = PatternState.NamedCaptureGroupQuote;
startNamedIndex = currentIndex + 1;
break;
case '<':
patternState = PatternState.StartNamedCaptureGroupAngleBracket;
startNamedIndex = currentIndex + 1;
break;
default:
patternState = PatternState.Other;
break;
}
break;
case PatternState.NamedCaptureGroupQuote: // (?'
if (token == '\'')
{
NamedCaptureGroupFound(startGroupIndex, currentIndex + 1, GetName(startNamedIndex, currentIndex));
patternState = PatternState.Other;
} //else we are inside the name
break;
case PatternState.StartNamedCaptureGroupAngleBracket: // (?<
// PositiveLookBehind: // (?<= -> Other
// NegativeLookBehind: // (?<! -> Other
if (token == '=' || token == '!')
{
patternState = PatternState.Other;
}
else
{
patternState = PatternState.NamedCaptureGroupAngleBracket;
}
break;
case PatternState.NamedCaptureGroupAngleBracket:
if (token == '>')
{
NamedCaptureGroupFound(startGroupIndex, currentIndex + 1, GetName(startNamedIndex, currentIndex));
patternState = PatternState.Other;
} //else we are inside the name
break;
default:
throw new NotSupportedException("Unknown group state");
}
}
else
{
switch (patternState)
{
case PatternState.StartCharacterClass:
patternState = PatternState.CharacterClass;
break;
case PatternState.StartExtendedGroup:
patternState = PatternState.Other;
break;
case PatternState.StartGroup:
if (previousPatternState == PatternState.StartExtendedGroup)
{
ConditionFound(currentIndex - 1);
}
else
{
NumberedCaptureGroupFound(startGroupIndex, currentIndex - 1);
}
patternState = PatternState.Other;
break;
case PatternState.StartNamedCaptureGroupAngleBracket:
patternState = PatternState.NamedCaptureGroupAngleBracket;
break;
}
}
}
public IdleState(PatternState patternStateEnemy)
{
enemy = patternStateEnemy;
}
public void FireBullet(Vector2 StartPos, float StartAngle, float StartSpeed, PatternState stat, PatternState bulletstat)
{
// m_eType = MoverType.Bullet;
m_cStat = stat;
m_cBulletStat = bulletstat;
transform.position = StartPos;
if (transform.localScale != stat.ScaleXY)
{
transform.localScale = stat.ScaleXY;
}
SetSprite(m_cStat.m_sImage);
m_fAngle = StartAngle;
m_fSpeed = StartSpeed;
m_eBulletType = m_cStat.m_eType;
PlayStopaAndMove();
InstallTraill();
m_isFire = true;
}
private static void HandleCharEvolvingPattern(Dictionary<char, SearchState> mapEvolvedStates, MultiMap<char, string> mapCompletedPatterns, PatternState ps, char c)
{
if (ps.DotPos + 1 == ps.PatternString.Length)
{
mapCompletedPatterns.Add(c, ps.PatternString);
}
if (!mapEvolvedStates.ContainsKey(c))
mapEvolvedStates.Add(c, new SearchState());
mapEvolvedStates[c].AddPatternState(ps.NextStep());
}
protected override bool OnCanExecute(PatternState state)
{
return(true);
}
protected override void createPattern()
{
PatternPackage newPs = null;
PatternState newPattern = new PatternState();
/////////////////////////////////////////////////////////////////////////////////////////////
newPattern.setPattern
(
true, // bool || isMix || 패턴을 다른 패턴과 조합해서 쓸것인지
PATTERN_NAME.WASHER_SPIRAL, // enum || PatternName || 무슨 패턴을 쓸건지?
0.5f, // float || XScale || X Scale 값 조정.
0.5f, // flaot || YScale || Y Scale 값 조정.
6.0f, // float || Speed || 탄환이 나갈 때 첫 속도
10.0f, // float || Angle || 탄환 첫 발사 각도
0.0f, // float || SpeedRate || 탄환이 나갈 때 첫 속도를 점점 올릴것인지?
10.0f, // float || AngleRate || 탄환이 나갈 때 발사 각도를 점점 올릴것인지? 샷건이나 부채꼬에서는 각도를 각 각도
0.1f, // float || Interval || 탄환 사이의 간격 (시간)
0.0f, // float || BulletSpeedRate || 탄환이 가속도
0.0f, // float || BulletAngleRate || 탄환의 각 증가속도?? 알아서 탄환의 각이 커짐.
4, // int || Count || 탄환을 한번에 발사 하는 놈의 수를 조정.
0.1f, // float || MinInterval || ShotGun ,Direct 패턴에서 탄환의 그룹안의 탄환간의 간격
10.0f, // float || RotateAngle || 거의 쓸일은 없겠지만, 회전 각 정하기? Washer에서 주로 쓰임.
0.00f, // float || RotateAngleRate || 탄환이 회전 하는 패턴을 가질 경우, 회전 각 속도 조정 Rotate 붙은 패턴에서 쓰임.
60.0f, // float || MaxAngle || Washer 회전 패턴의 경우, 최대 돌 각도가 어느정도인지?
0, // int || GroupCount || ShotGun Pattern에서만 쓰임. Shot Group 수 결정. 0으로 둬도 무방.
BULLET_TYPE.BASE, // enum || BulletType || 탄막의 종류는? 안쓰면 Blue값이 Default
BULLET_IMAGE.BASE_BULLET1_1, // enum || BulletImage || 탄막의 이미지 타입은?
0.0f, // float || HomingRate || 유도탄의 유도정도, 유도탄 안쓰면 0.0f
false, // bool || isHoming || 유도탄으로 발사할건가?
0.0f, // float || MoveTime || 탄환을 처음 어느 정도 움직일 것인가>
0.0f); // float || StopTime || 탄환을 어느 정도 멈추고 다시 진행할 것인가)
newPs = new PatternPackage(newPattern, "B_Green", "E_3", "E_3", "M_1", m_moveList[0]);
m_curPatternList.Add(newPs);
newPattern = new PatternState();
newPattern.setPattern
(
true, // bool || isMix || 패턴을 다른 패턴과 조합해서 쓸것인지
PATTERN_NAME.WASHER_SPIRAL, // enum || PatternName || 무슨 패턴을 쓸건지?
0.5f, // float || XScale || X Scale 값 조정.
0.5f, // flaot || YScale || Y Scale 값 조정.
6.0f, // float || Speed || 탄환이 나갈 때 첫 속도
0.0f, // float || Angle || 탄환 첫 발사 각도
0.0f, // float || SpeedRate || 탄환이 나갈 때 첫 속도를 점점 올릴것인지?
-10.0f, // float || AngleRate || 탄환이 나갈 때 발사 각도를 점점 올릴것인지? 샷건이나 부채꼬에서는 각도를 각 각도
0.1f, // float || Interval || 탄환 사이의 간격 (시간)
0.0f, // float || BulletSpeedRate || 탄환이 가속도
0.0f, // float || BulletAngleRate || 탄환의 각 증가속도?? 알아서 탄환의 각이 커짐.
4, // int || Count || 탄환을 한번에 발사 하는 놈의 수를 조정.
0.1f, // float || MinInterval || ShotGun ,Direct 패턴에서 탄환의 그룹안의 탄환간의 간격
0.0f, // float || RotateAngle || 거의 쓸일은 없겠지만, 회전 각 정하기? Washer에서 주로 쓰임.
0.00f, // float || RotateAngleRate || 탄환이 회전 하는 패턴을 가질 경우, 회전 각 속도 조정 Rotate 붙은 패턴에서 쓰임.
60.0f, // float || MaxAngle || Washer 회전 패턴의 경우, 최대 돌 각도가 어느정도인지?
0, // int || GroupCount || ShotGun Pattern에서만 쓰임. Shot Group 수 결정. 0으로 둬도 무방.
BULLET_TYPE.BASE, // enum || BulletType || 탄막의 종류는? 안쓰면 Blue값이 Default
BULLET_IMAGE.BASE_BULLET1_1, // enum || BulletImage || 탄막의 이미지 타입은?
0.0f, // float || HomingRate || 유도탄의 유도정도, 유도탄 안쓰면 0.0f
false, // bool || isHoming || 유도탄으로 발사할건가?
0.0f, // float || MoveTime || 탄환을 처음 어느 정도 움직일 것인가>
0.0f); // float || StopTime || 탄환을 어느 정도 멈추고 다시 진행할 것인가)
newPs = new PatternPackage(newPattern, "B_Green", "E_3", "E_3", "M_1", m_moveList[0]);
m_curPatternList.Add(newPs);
newPattern = new PatternState();
newPattern.setPattern
(
false, // bool || isMix || 패턴을 다음에 쓰는 SetPattern 패턴과 조합해서 쓸것인지? true면 yes 아니면 false
PATTERN_NAME.AIMING_DIRECT, // enum || PatternName || 무슨 패턴을 쓸건지?
0.7f, // float || XScale || X Scale 값 조정.
0.7f, // flaot || YScale || Y Scale 값 조정.
5.0f, // float || Speed || 탄환이 나갈 때 첫 속도
30.0f, // float || Angle || 탄환 첫 발사 각도
0.0f, // float || SpeedRate || 탄환이 나갈 때 첫 속도를 점점 올릴것인지?
0.0f, // float || AngleRate || 탄환이 나갈 때 발사 각도를 점점 올릴것인지? 샷건이나 부채꼬에서는 각도를 각 각도
1.0f, // float || Interval || 탄환 사이의 간격 (시간)
0.0f, // float || BulletSpeedRate || 탄환이 가속도
0.0f, // float || BulletAngleRate || 탄환의 각 증가속도?? 알아서 탄환의 각이 커짐.
3, // int || Count || 탄환을 한번에 발사 하는 놈의 수를 조정.
0.1f, // float || MinInterval || ShotGun ,Direct 패턴에서 탄환의 그룹안의 탄환간의 간격
0.0f, // float || RotateAngle || 거의 쓸일은 없겠지만, 회전 각 정하기? Washer에서 주로 쓰임.
0.00f, // float || RotateAngleRate || 탄환이 회전 하는 패턴을 가질 경우, 회전 각 속도 조정 Rotate 붙은 패턴에서 쓰임.
0.0f, // float || MaxAngle || Washer 회전 패턴의 경우, 최대 돌 각도가 어느정도인지?
0, // int || GroupCount || ShotGun Pattern에서만 쓰임. Shot Group 수 결정. 0으로 둬도 무방.
BULLET_TYPE.BASE, // enum || BulletType || 탄막의 종류는? 안쓰면 Blue값이 Default
BULLET_IMAGE.BASE_BULLET1_2, // enum || BulletImage || 탄막의 이미지 타입은?
0.0f, // float || HomingRate || 유도탄의 유도정도, 유도탄 안쓰면 0.0f
false, // bool || isHoming || 유도탄으로 발사할건가?
0.0f, // float || MoveTime || 탄환을 처음 어느 정도 움직일 것인가>
1.0f, // float || StopTime || 탄환을 어느 정도 멈추고 다시 진행할 것인가)
true, // bool || isMyPos || 발사 위치를 내 자리에 아니면 사용자가 지정한 위치에 둘것인지??
0.0f, // float || StopTime || 탄환의 시작 위치 X값
0.0f); // float || StopTime || 탄환의 시작 위치 Y값
newPs = new PatternPackage(newPattern, "B_Green", "E_3", "E_3", "M_4", m_moveList[0]);
m_curPatternList.Add(newPs);
///////////////////////////////////////////////////////////////////////
// 페이즈 2
////////////////////////////////////////////////////////////////////////
newPattern = new PatternState();
newPattern.setPattern
(
true, // bool || isMix || 패턴을 다른 패턴과 조합해서 쓸것인지
PATTERN_NAME.ROTATE_CIRCULAR, // enum || PatternName || 무슨 패턴을 쓸건지?
0.6f, // float || XScale || X Scale 값 조정.
0.6f, // flaot || YScale || Y Scale 값 조정.
3.0f, // float || Speed || 탄환이 나갈 때 첫 속도
0.0f, // float || Angle || 탄환 첫 발사 각도
0.5f, // float || SpeedRate || 탄환이 나갈 때 첫 속도를 점점 올릴것인지?
10.0f, // float || AngleRate || 탄환이 나갈 때 발사 각도를 점점 올릴것인지? 샷건이나 부채꼬에서는 각도를 각 각도
0.45f, // float || Interval || 탄환 사이의 간격 (시간)
0.0f, // float || BulletSpeedRate || 탄환이 가속도
12f, // float || BulletAngleRate || 탄환의 각 증가속도?? 알아서 탄환의 각이 커짐.
18, // int || Count || 탄환을 한번에 발사 하는 놈의 수를 조정.
0.1f, // float || MinInterval || ShotGun ,Direct 패턴에서 탄환의 그룹안의 탄환간의 간격
0.0f, // float || RotateAngle || 거의 쓸일은 없겠지만, 회전 각 정하기? Washer에서 주로 쓰임.
10.00f, // float || RotateAngleRate || 탄환이 회전 하는 패턴을 가질 경우, 회전 각 속도 조정 Rotate 붙은 패턴에서 쓰임.
0.0f, // float || MaxAngle || Washer 회전 패턴의 경우, 최대 돌 각도가 어느정도인지?
0, // int || GroupCount || ShotGun Pattern에서만 쓰임. Shot Group 수 결정. 0으로 둬도 무방.
BULLET_TYPE.BASE, // enum || BulletType || 탄막의 종류는? 안쓰면 Blue값이 Default
BULLET_IMAGE.BASE_BULLET1_1, // enum || BulletImage || 탄막의 이미지 타입은?
0.0f, // float || HomingRate || 유도탄의 유도정도, 유도탄 안쓰면 0.0f
false, // bool || isHoming || 유도탄으로 발사할건가?
0.0f, // float || MoveTime || 탄환을 처음 어느 정도 움직일 것인가>
0.0f); // float || StopTime || 탄환을 어느 정도 멈추고 다시 진행할 것인가)
newPs = new PatternPackage(newPattern, "B_Green", "E_3", "E_3", "M_1", m_moveList[1]);
m_curPatternList.Add(newPs);
newPattern = new PatternState();
newPattern.setPattern
(
false, // bool || isMix || 패턴을 다른 패턴과 조합해서 쓸것인지
PATTERN_NAME.ROTATE_CIRCULAR, // enum || PatternName || 무슨 패턴을 쓸건지?
0.6f, // float || XScale || X Scale 값 조정.
0.6f, // flaot || YScale || Y Scale 값 조정.
3.0f, // float || Speed || 탄환이 나갈 때 첫 속도
0.0f, // float || Angle || 탄환 첫 발사 각도
0.5f, // float || SpeedRate || 탄환이 나갈 때 첫 속도를 점점 올릴것인지?
-12.0f, // float || AngleRate || 탄환이 나갈 때 발사 각도를 점점 올릴것인지? 샷건이나 부채꼬에서는 각도를 각 각도
0.45f, // float || Interval || 탄환 사이의 간격 (시간)
0.0f, // float || BulletSpeedRate || 탄환이 가속도
-0.8f, // float || BulletAngleRate || 탄환의 각 증가속도?? 알아서 탄환의 각이 커짐.
18, // int || Count || 탄환을 한번에 발사 하는 놈의 수를 조정.
0.1f, // float || MinInterval || ShotGun ,Direct 패턴에서 탄환의 그룹안의 탄환간의 간격
0.0f, // float || RotateAngle || 거의 쓸일은 없겠지만, 회전 각 정하기? Washer에서 주로 쓰임.
10.00f, // float || RotateAngleRate || 탄환이 회전 하는 패턴을 가질 경우, 회전 각 속도 조정 Rotate 붙은 패턴에서 쓰임.
0.0f, // float || MaxAngle || Washer 회전 패턴의 경우, 최대 돌 각도가 어느정도인지?
0, // int || GroupCount || ShotGun Pattern에서만 쓰임. Shot Group 수 결정. 0으로 둬도 무방.
BULLET_TYPE.BASE, // enum || BulletType || 탄막의 종류는? 안쓰면 Blue값이 Default
BULLET_IMAGE.BASE_BULLET1_2, // enum || BulletImage || 탄막의 이미지 타입은?
0.0f, // float || HomingRate || 유도탄의 유도정도, 유도탄 안쓰면 0.0f
false // bool || isHoming || 유도탄으로 발사할건가?
);
newPs = new PatternPackage(newPattern, "B_Green", "E_3", "E_3", "M_1", m_moveList[1]);
newPs.m_PPDelay = 0.15f;
m_curPatternList.Add(newPs);
///////////////////////////////////////////////////////////////////////
// 페이즈 3
////////////////////////////////////////////////////////////////////////
for (int i = 0; i < 3; i++)
{
newPattern = new PatternState();
newPattern.setPattern
(
true, // bool || isMix || 패턴을 다른 패턴과 조합해서 쓸것인지
PATTERN_NAME.ROTATE_CIRCULAR, // enum || PatternName || 무슨 패턴을 쓸건지?
0.6f, // float || XScale || X Scale 값 조정.
0.6f, // flaot || YScale || Y Scale 값 조정.
4.0f, // float || Speed || 탄환이 나갈 때 첫 속도
0.0f, // float || Angle || 탄환 첫 발사 각도
0.5f, // float || SpeedRate || 탄환이 나갈 때 첫 속도를 점점 올릴것인지?
10.0f, // float || AngleRate || 탄환이 나갈 때 발사 각도를 점점 올릴것인지? 샷건이나 부채꼬에서는 각도를 각 각도
1.5f, // float || Interval || 탄환 사이의 간격 (시간)
0.0f, // float || BulletSpeedRate || 탄환이 가속도
28.0f + 3.0f * i, // float || BulletAngleRate || 탄환의 각 증가속도?? 알아서 탄환의 각이 커짐.
36, // int || Count || 탄환을 한번에 발사 하는 놈의 수를 조정.
0.1f, // float || MinInterval || ShotGun ,Direct 패턴에서 탄환의 그룹안의 탄환간의 간격
0.0f, // float || RotateAngle || 거의 쓸일은 없겠지만, 회전 각 정하기? Washer에서 주로 쓰임.
15.00f, // float || RotateAngleRate || 탄환이 회전 하는 패턴을 가질 경우, 회전 각 속도 조정 Rotate 붙은 패턴에서 쓰임.
0.0f, // float || MaxAngle || Washer 회전 패턴의 경우, 최대 돌 각도가 어느정도인지?
0, // int || GroupCount || ShotGun Pattern에서만 쓰임. Shot Group 수 결정. 0으로 둬도 무방.
BULLET_TYPE.STOP_AND_PLAY, // enum || BulletType || 탄막의 종류는? 안쓰면 Blue값이 Default
BULLET_IMAGE.BASE_BULLET1_2, // enum || BulletImage || 탄막의 이미지 타입은?
0.0f, // float || HomingRate || 유도탄의 유도정도, 유도탄 안쓰면 0.0f
false, // bool || isHoming || 유도탄으로 발사할건가?
0.05f + (i * 0.05f), // float || MoveTime || 탄환을 처음 어느 정도 움직일 것인가>
0.8f + (i * 0.1f)); // float || StopTime || 탄환을 어느 정도 멈추고 다시 진행할 것인가)
newPs = new PatternPackage(newPattern, "B_Green", "E_3", "E_3", "M_1", m_moveList[0]);
m_curPatternList.Add(newPs);
}
}
private void LeaveEscapeSequence()
{
_state &= ~PatternState.InEscapeSequence;
}
public TonePatternDetector(IConfigurationReader configurationReader)
{
_targetFrequency1 = configurationReader.ReadToneFrequency1();
_targetFrequency2 = configurationReader.ReadToneFrequency2();
_state = PatternState.NoTargetFrequencyDetected;
}
private void EvalCommentsState(char token, bool escaped)
{
switch (commentsState)
{
case CommentsState.None:
if (!escaped)
{
if (token == '#')
{
if (patternState == PatternState.StartGroup)
{
commentsState = CommentsState.CommentsGroup;
}
else if (ignorePatternWhitespace)
{
commentsState = CommentsState.CommentsLine;
}
else
{
EvalGroupState(token, escaped);
}
}
else
{
EvalGroupState(token, escaped);
}
}
else
{
EvalGroupState(token, escaped);
}
break;
case CommentsState.CommentsLine:
if(token == 'n' && escaped)
{
commentsState = CommentsState.None;
}
break;
case CommentsState.CommentsGroup:
if (token == ')' && !escaped)
{
CommentsGroupFound(startGroupIndex, currentIndex+1);
groupLevel--;
patternState = previousPatternState;
startGroupIndex = previousStartGroupIndex;
commentsState = CommentsState.None;
}
break;
}
}
public void Reset()
{
_state = PatternState.NoTargetFrequencyDetected;
}
private void OnOpenBracket() {
if (InEscapeSequence) {
AppendEscapedChar('[');
} else if (InCharacterClass) {
if (!CheckReplacePredefinedCharacterClass()) {
// TODO - Ruby 1.9 allows "/[a[b]]/". Not sure what this means. So we really will need to keep nesting count.
// We need the nesting count anyway for "/[a&&[b]]/"
_sb.Append('[');
}
} else {
_sb.Append('[');
_state |= PatternState.InCharacterClass;
}
}
public void AddPatternState(PatternState newState)
{
m_patternStates.Add(newState, true);
}
private void LeaveEscapeSequence() {
_state &= ~PatternState.InEscapeSequence;
}
protected override bool OnExecute(PatternState state)
{
state.AddToCollection(state.Enumerator.Current);
state.Enumerator.MoveNext();
return(true);
}
private void StartPlayerTurn()
{
if (OnPatternPlayerTurnStart != null)
OnPatternPlayerTurnStart();
patternState = PatternState.PLAYER_TURN_WAIT_INPUT;
RestartPattern();
}
private protected virtual IPattern ClonePattern()
{
return(PatternState.CloneNode());
}
protected override bool OnExecute(PatternState state)
{
int lastEnumeratorIndex = state.Enumerator.Index;
EndElement optionalEnd = null;
for (int i = 0; i < Elements.Count; i++)
{
PatternElement element = Elements[i];
// Special case for optional end elements
// They can always be executed, but whether or not they
// should be depends on if the next element can be.
if (element is OptionalElement option &&
option.Value is EndElement endElement)
{
optionalEnd = endElement;
continue;
}
if (!element.CanExecute(state))
{
if (optionalEnd != null)
{
optionalEnd.Execute(state);
return(true);
}
return(false);
}
bool success = element.Execute(state);
if (!success)
{
return(false);
}
switch (state.Command)
{
case PatternCommand.Break:
state.ClearCommand();
return(true);
case PatternCommand.Loopback:
state.ClearCommand();
if (state.Enumerator.Index == lastEnumeratorIndex)
{
throw new Exception("Possible infinite loopback detected");
}
// i will be incremented to 0 at the end of the iteration
// and the loop will begin again. I'm curious, though,
// is there a more readable way to designate that the loop
// should start over?
i = -1;
continue;
case PatternCommand.End:
return(true);
}
// An optional end only applied to the CanExecute
// until the first non-optional, non-command, element after it.
if (!(element is OptionalElement))
{
optionalEnd = null;
}
}
return(true);
}
public AttackState(PatternState patternStateEnemy)
{
enemy = patternStateEnemy;
}
public void PlayerDidMove(int moveIndex)
{
if (patternState == PatternState.PLAYER_TURN_WAIT_INPUT)
{
bool isFail = false;
currentFrame = -1;
playerMoveFrame = 0;
if (!beatManager.IsInTheBeat())
isFail = true;
if (moveIndex != moveList[playerMoveFrame])
isFail = true;
++playerMoveFrame;
if (isFail)
PatternFailed();
else
{
if (OnCorrectMove != null)
OnCorrectMove ();
}
patternState = PatternState.PLAYER_TURN;
}
else if (patternState == PatternState.PLAYER_TURN)
{
bool isFail = false;
if (!beatManager.IsInTheBeat())
isFail = true;
if (playerMoveFrame >= moveList.Count || moveIndex != moveList[playerMoveFrame])
isFail = true;
++playerMoveFrame;
if (isFail)
PatternFailed();
else
{
if (OnCorrectMove != null)
OnCorrectMove ();
if (playerMoveFrame >= moveList.Count)
{
PatternComplete ();
}
}
}
}
protected override bool OnExecute(PatternState state)
{
state.SetCommand(Value);
return(true);
}
