void Start()
{
this.GetFiles("Vibration Patterns");
MenuManager menuManager = GetComponent <MenuManager>();
float slotHeight = menuManager.slotPrefab.GetComponent <RectTransform>().rect.height;
menuManager.scrollViewContent.GetComponent <RectTransform>().sizeDelta = new Vector2(0, slotHeight * (RoukaViciController.instance.vibrationPatterns.Count + 1));
int i = 0;
foreach (VibrationPattern vs in RoukaViciController.instance.vibrationPatterns)
{
GameObject button = Instantiate(menuManager.slotPrefab);
button.transform.SetParent(menuManager.scrollViewContent, false);
button.GetComponentInChildren <Text>().text = vs.getName();
PatternData data = button.GetComponent <PatternData>();
data.ID = i;
data.selectPattern.onClick.AddListener(delegate { RoukaViciController.instance.setVibrationPattern(data.ID); });
data.editPattern.onClick.AddListener(delegate { menuManager.EditPattern(data.ID); });
data.removePattern.onClick.AddListener(delegate { menuManager.RemovePattern(data.ID); });
RoukaViciController.instance.patternButtons.Add(button);
i += 1;
}
menuManager.InitializeUI();
}
IEnumerator SpawnBullets(Vector3 bulletMoveVector, Vector2 bulletDirection, PatternData patternData)
{
for (int y = 0; y < patternData.BulletStackAmount; y++)
{
GameObject bulletPoolAccordingToShape = GetBulletPoolAccordingToShape(patternData.BulletData.Shape);
GameObject bullet = bulletPoolAccordingToShape.GetComponent <ObjectPool>().GetObject();
bullet.transform.position = bulletMoveVector;
bullet.GetComponent <Bullet>().SetBulletData(patternData.BulletData);
if (patternData.AimedAtPlayer)
{
if (FindObjectOfType <Player>())
{
bullet.GetComponent <Bullet>().SetInitialMovementDirection((FindObjectOfType <Player>().transform.position));
}
}
else
{
bullet.GetComponent <Bullet>().SetInitialMovementDirection(bulletDirection);
}
bullet.SetActive(true);
yield return(new WaitForSeconds(patternData.TimeBetweenBulletStackSpawns));
}
}
//描画頂点データに対してForeachする（途中でberakした場合はfalseが帰る）
protected void ForeachVertexList(Action <Rect, Rect> function)
{
//描画領域
Rect r = GetPixelAdjustedRect();
PatternData.ForeachVertexList(r, this.uvRect, this.skipTransParentCell, this.DicingData, function);
}
/// <summary>
/// Takes a pattern and its origin point and removes all the patterns that fall outside board.
/// </summary>
/// <param name="patterns"></param>
/// <param name="origin"></param>
/// <returns></returns>
public virtual List <PatternData> InterpretPattern(List <PatternData> patterns, Vector2Int origin)
{
List <PatternData> returnList = new List <PatternData>();
foreach (PatternData pat in patterns)
{
PatternData tempPat = CreateInstance <PatternData>();
List <Vector2Int> returnPat = new List <Vector2Int>();
foreach (Vector2Int pos in pat.positions)
{
Vector2Int resultingPos = origin + pos;
if (resultingPos.x < 0 || resultingPos.x > Board.BoardInstance.Width - 1 || resultingPos.y < 0 || resultingPos.y > Board.BoardInstance.Height - 1) // outside of the board
{
break;
}
returnPat.Add(resultingPos);
}
tempPat.positions = returnPat;
returnList.Add(tempPat);
}
return(returnList);
}
private void UpdateSelectedPattern(PatternData data)
{
m_SelectedPattern = data;
if (m_SelectedPattern != null)
{
SetReponseEnables(true);
DataEnums.EnumWrapper <HttpMethod>[] HttpMethodDataSource = comboBoxHttpMethod.DataSource as DataEnums.EnumWrapper <HttpMethod>[];
comboBoxHttpMethod.SelectedItem = HttpMethodDataSource.Where(c => c.Value == data.HttpMethod).First();
DataEnums.EnumWrapper <HttpStatusCode>[] HttpStatusCodeDataSource = comboBoxStatusCode.DataSource as DataEnums.EnumWrapper <HttpStatusCode>[];
comboBoxStatusCode.SelectedItem = HttpStatusCodeDataSource.Where(c => c.Value == data.ResponseData.ResponseCode).First();
DataEnums.EnumWrapper <ContentType>[] ContentTypeDataSource = comboBoxContentType.DataSource as DataEnums.EnumWrapper <ContentType>[];
comboBoxContentType.SelectedItem = ContentTypeDataSource.Where(c => c.Value == data.ResponseData.ContentType).First();
checkBoxReponseDelay.Checked = data.ResponseData.UseResponseDelay;
txtResponseDelay.Text = data.ResponseData.ResponseDelay.ToString();
rtbResponse.Text = data.ResponseData.ResponseBody;
}
else
{
SetReponseEnables(false);
toolStripButtonRemovePattern.Enabled = false;
}
}
static bool TryGetDataFromAttr(AttributeData attr, out PatternData data)
{
var args = attr.ConstructorArguments;
if (args.Length != 2)
{
goto FAILURE;
}
var pattern = args[0].Value?.ToString();
var replacement = args[1].Value?.ToString();
if (pattern == null || replacement == null)
{
goto FAILURE;
}
try {
data = new PatternData(new Regex(pattern), replacement);
return(true);
}
catch {
data = default;
return(false);
}
FAILURE:
data = default;
return(false);
}
void UpdatePatternData()
{
currentPatternData = BinaryLoader.LoadPatternData(currentSpellcard, currentSave);
//if the file does not exists:
if (currentPatternData == null)
{
currentPatternData = new PatternData();
currentPatternData.name = "Spellcard name";
}
for (int i = 0; i < previewParticleSystems.Length; i++)
{
var emission = previewParticleSystems[i].emission;
if (i < currentPatternData.particlePatterns.Count)
{
ParticleSystemScript.SetPSFromData(previewParticleSystems[i], currentPatternData.particlePatterns[i]);
emission.enabled = true;
}
else
{
emission.enabled = false;
}
}
spellcardName.text = currentPatternData.name;
}
public void HoveredHighlightCells(PatternData pattern)
{
foreach (Vector2Int pos in pattern.positions)
{
//Vector2Int resultingPos = origin + pos;
_board.CellLayer[pos.x, pos.y].UpdateState(CellState.HOVERED);
}
}
public static string SavePatternData(PatternData pattern, int patternIndex, int saveIndex)
{
string path = Serialize <PatternData>(pattern, GetPatternDataPath(patternIndex, saveIndex));
if (path != null)
{
return(Path.GetFileNameWithoutExtension(path));
}
return(null);
}
//Event Handlers
private void toolStripButtonAdd_Click(object sender, EventArgs e)
{
using (AddMockResponseDialog AMRD = new AddMockResponseDialog())
{
if (AMRD.ShowDialog() == DialogResult.OK)
{
PatternData newData = new PatternData(AMRD.MockResponseName);
m_EndpointData.AddPattern(newData);
}
}
}
MarkerData convertToMarkerData(JSONNode json)
{
MarkerData data = new MarkerData();
var polygonData = json["polygon"].AsArray;
var edgesData = json["edges"].AsArray;
var indicesData = json["indices"].AsArray;
var patternsData = json["patterns"].AsArray;
var polygon = new List <Vector3>();
var edges = new List <EdgeData>();
var indices = new List <int>();
var patterns = new List <PatternData>();
foreach (JSONClass vert in polygonData)
{
polygon.Add(new Vector3(sign * vert["x"].AsFloat, 0, sign * vert["y"].AsFloat));
}
foreach (JSONClass edgeData in edgesData)
{
var edge = new EdgeData();
var dir = edgeData["direction"].AsObject;
edge.id = edgeData["id"].AsInt;
edge.pos = new Vector3(sign * edgeData["x"].AsFloat, 0, sign * edgeData["y"].AsFloat);
edge.dir = new Vector3(sign * dir["x"].AsFloat, 0, sign * dir["y"].AsFloat);
edges.Add(edge);
}
foreach (JSONData index in indicesData)
{
indices.Add(index.AsInt);
}
foreach (JSONClass pattern in patternsData)
{
var p = new PatternData();
var ids = pattern["ids"].AsArray;
p.pattern = pattern["pattern"].AsInt;
foreach (JSONData id in ids)
{
p.ids.Add(id.AsInt);
}
patterns.Add(p);
}
data.id = json["id"].AsInt;
data.pos = new Vector3(sign * json["x"].AsFloat, 0f, sign * json["y"].AsFloat);
data.size = json["size"].AsFloat;
data.angle = json["angle"].AsFloat;
data.polygon = polygon;
data.edges = edges;
data.indices = indices;
data.edges = edges;
data.patterns = patterns;
return(data);
}
private void toolStripButtonRemovePattern_Click(object sender, EventArgs e)
{
if (listViewResponses.SelectedItems.Count == 1)
{
ListViewItem thisItem = listViewResponses.SelectedItems[0];
if (thisItem.Tag is PatternData)
{
PatternData thisData = thisItem.Tag as PatternData;
m_EndpointData.RemovePattern(thisData);
thisItem.Remove();
}
}
}
private void AddPattern(PatternData data)
{
ListViewItem newReponseItem = new ListViewItem(data.DetailedName);
newReponseItem.Tag = data;
listViewResponses.Items.Add(newReponseItem);
newReponseItem.Text = data.DetailedName + " )";
newReponseItem.Text = data.DetailedName;
UpdateSelectedPattern(data);
}
private void Start()
{
s = GetComponent <Ship>();
pd = patternData.GetComponent <PatternData>();
waypoints = pd.waypoints;
if (pd.reverse)
{
waypoints.Reverse();
}
currentWaypoint = 0;
}
internal static PatternVM Convert(PatternData value)
{
var result = new PatternVM
{
PatternID = value.PatternID,
Type = (Categories.enCategoryType)value.Type,
Text = value.Text,
CategoryID = value.CategoryID,
CategoryRow = Categories.CategoryVM.Convert(value.CategoryDetails),
Count = value.Count
};
return(result);
}
public void OnPattern(PatternData pattern, Dictionary <int, GameObject> edgeMap)
{
List <GameObject> edges = new List <GameObject>();
foreach (var id in pattern.ids)
{
if (!edgeMap.ContainsKey(id))
{
return;
}
edges.Add(edgeMap[id]);
}
OnPattern(edges);
}
public virtual void Execute(PatternData pattern, Vector2Int origin)
{
List <PatternData> tempList = new List <PatternData> {
pattern
};
List <PatternData> useList = InterpretPattern(tempList, origin);
foreach (PatternData pat in useList)
{
foreach (Vector2Int pos in pat.positions)
{
Debug.Log("Tile being affected is " + pos);
}
}
}
IEnumerator PlayPattern(PatternData pattern)
{
patternTimer = 0f;
RandomPowers = pattern.allowRandomPower;
foreach (float f in pattern.patterns.Keys)
{
while (patternTimer < f * 2)
{
patternTimer += Time.deltaTime;
yield return(new WaitForFixedUpdate());
}
if (pattern.allowMirrorimages)
{
switch (Random.Range(0, 3))
{
case 0:
foreach (int i in pattern.patterns[f])
{
GenerateObstacle(i);
}
break;
case 1:
foreach (int i in pattern.patterns[f])
{
GenerateObstacles_SphericalSymmetric(i);
}
break;
case 2:
foreach (int i in pattern.patterns[f])
{
GenerateObstacles_BilateralSymmetric(i);
}
break;
}
}
else
{
foreach (int i in pattern.patterns[f])
{
GenerateObstacle(i);
}
}
}
RandomPowers = true;
StartCoroutine(WaitPattern());
}
public static PatternData LoadPatternData(int patternIndex, int saveIndex)
{
PatternData pattern = Deserialize <PatternData>(GetPatternDataPath(patternIndex, saveIndex));
if (pattern != null)
{
return(pattern);
}
if (saveIndex != 0)
{
return(null);
}
return(Deserialize <PatternData>(GetDefaultPatternDataPath(patternIndex, saveIndex)));
}
void Start()
{
rigidbody = GetComponent <Rigidbody>();
HPSlider = HPbar.GetComponent <Slider>();
HP = HPmax;
//Load the spellcards using the current save number;
int saveIndex = Global.GetCurrentSaveIndex();
patterns.Clear();
for (int i = 0; i < 5; i++)
{
PatternData data = BinaryLoader.LoadPatternData(i, saveIndex);
if (data != null)
{
var pattern = ParticleSystemScript.GetPSListFromDataList(data, transform);
//set loop to true for auto attack
if (i == 0)
{
foreach (var ps in pattern.particleSystems)
{
var main = ps.main;
main.loop = true;
}
}
patterns.Add(pattern);
}
}
//disable all particle system emissions
foreach (var kp in patterns)
{
foreach (var system in kp.particleSystems)
{
var emission = system.emission;
emission.enabled = false;
}
}
ActivateSpellCard(0);
}
private void AddPatternPart(string pattern)
{
PatternData data = _patterns[pattern];
IContentPart part;
if (data.FunctionType.HasValue)
{
part = new FunctionPart(data.FunctionType.Value);
}
else
{
part = new DataPart(data.ColumnOrdinal);
}
_parts.Add(part);
}
public PatternViewModel(PatternData data)
{
Data = data;
Pattern = new ObservableValue<string>(data.Regex.ToString());
Enabled = new ObservableValue<bool>(data.Enabled);
IsEmpty = Pattern.GetObservable(string.IsNullOrEmpty);
Enabled.PropertyChanged += (sender, e) => {
data.Enabled = ((ObservableValue<bool>)sender).Value;
};
Pattern.PropertyChanged += (sender, e) => {
var pattern = ((ObservableValue<string>) sender).Value;
if (string.IsNullOrEmpty(pattern))
return;
data.Regex = new Regex(pattern);
};
}
// Use this for initialization
void Start()
{
predator = Instantiate(predator, startPosition.transform.position, Quaternion.identity);
predator.AddComponent <Rigidbody>();
predatorBody = predator.GetComponent <Rigidbody>();
Vector3 stepVector = predator.transform.forward;
pattern = new PatternData[]
{
new PatternData(Movement.Step, stepVector * speed, Time.deltaTime * 45),
new PatternData(Movement.Turn, Quaternion.Euler(0, 90f, 0), Time.deltaTime * 45),
new PatternData(Movement.Step, transform.right * speed, Time.deltaTime * 45),
new PatternData(Movement.Turn, Quaternion.Euler(0, -90f, 0), Time.deltaTime * 45)
};
currentStep = 0;
}
static public PlayerPattern GetPSListFromDataList(PatternData pd, Transform parent)
{
GameObject prefab = Resources.Load <GameObject>("defaultParticleSsytem");
PlayerPattern playerPattern = new PlayerPattern();
foreach (ParticleSystemData psd in pd.particlePatterns)
{
GameObject psh = GameObject.Instantiate(prefab, parent.position, parent.rotation, parent);
ParticleSystem tmpps = psh.GetComponent <ParticleSystem>();
SetPSHromData(psh, psd);
playerPattern.particleSystems.Add(tmpps);
}
playerPattern.cooldown = pd.cooldown;
playerPattern.duration = pd.duration;
return(playerPattern);
}
private PatternData[] GetPatternData(Pattern[] renoisePatterns, SequencerTrack[] sequencerTracks, int numMasterTrackColumns)
{
PatternData[] patternsData = new PatternData[renoisePatterns.Length];
for (int cp = 0; cp < renoisePatterns.Length; cp++)
{
TrackLineData[] tracksLineData = GetLineTrackDataFromPattern(renoisePatterns[cp], sequencerTracks);
MasterTrackLineData[] masterTracksLineData = GetMasterTrackDataFromPattern(renoisePatterns[cp], numMasterTrackColumns);
patternsData[cp].TracksLineData = tracksLineData;
patternsData[cp].MasterTrackLineData = masterTracksLineData;
patternsData[cp].NumRows = renoisePatterns[cp].NumberOfLines;
}
return(patternsData);
}
private void listViewResponses_SelectedIndexChanged(object sender, EventArgs e)
{
if (listViewResponses.SelectedItems.Count > 1)
{
UpdateSelectedPattern(null);
}
else if (listViewResponses.SelectedItems.Count == 1)
{
ListViewItem thisItem = listViewResponses.SelectedItems[0];
if (thisItem.Tag is PatternData)
{
PatternData thisData = thisItem.Tag as PatternData;
UpdateSelectedPattern(thisData);
}
}
else
{
UpdateSelectedPattern(null);
}
}
IEnumerator StartPattern(PatternData pattern)
{
yield return(new WaitForSecondsRealtime(1));
foreach (float f in pattern.patterns.Keys)
{
while (patternTimer < f * 2)
{
patternTimer += Time.deltaTime;
yield return(new WaitForFixedUpdate());
}
foreach (int i in pattern.patterns[f])
{
GenerateObstacle(i);
}
}
StartCoroutine(WaitPattern());
}
private void ShowInverted()
{ //Effect 3
for (int i = 0; i < GameBrain.instance.FdEffect2.Length; i++)
{
GameBrain.instance.FdEffect2[i].SetShaderData(i, Frame);
}
GameBrain.instance.ColData.SetShaderData(Frame);
Frame += direction;
if ((Frame >= 45) || (Frame < 0))
{
direction *= -1;
Frame += direction;
for (int i = 0; i < 4; i++)
{
PatternData tmp = GameBrain.instance.FdEffect2[i * 2].ptrndata;
GameBrain.instance.FdEffect2[i * 2].ptrndata =
GameBrain.instance.FdEffect2[i * 2 + 1].ptrndata;
GameBrain.instance.FdEffect2[i * 2 + 1].ptrndata = tmp;
}
}
}
private void SpawnShip(ShipData s, float weaponOffset)
{
GameObject newPattern = Instantiate(s.pattern);
PatternData newPatternData = newPattern.GetComponent <PatternData>();
Transform spawnPoint = newPatternData.waypoints[0];
newPatternData.waypoints.RemoveAt(0);
GameObject ship = Instantiate(s.spawnType, spawnPoint.position, spawnPoint.rotation, Gamemaster.ships.transform);
EnemyShip es = ship.GetComponent <EnemyShip>();
WeaponComponent wc = ship.GetComponentInChildren <WeaponComponent>();
wc.SetInitialFireTime(weaponOffset);
Logger.Instance.LogSpawn(es.stats, newPatternData);
Gamemaster.Instance.totalPossiblePoints += es.stats.score; // Even if ship doesn't break, total score goes up
EnemyPatternComponent epc = ship.AddComponent <EnemyPatternComponent>();
epc.patternData = newPattern;
Destroy(newPattern);
}
public override List <PatternData> InterpretPattern(List <PatternData> patterns, Vector2Int origin)
{
patterns = base.InterpretPattern(patterns, origin);
List <PatternData> returnList = new List <PatternData>();
foreach (PatternData pat in patterns)
{
PatternData tempPat = CreateInstance <PatternData>();
List <Vector2Int> returnPat = new List <Vector2Int>();
foreach (Vector2Int pos in pat.positions)
{
Vector2Int resultingPos = pos;
// Conditions for modifying the pattern
returnPat.Add(resultingPos);
}
tempPat.positions = returnPat;
returnList.Add(tempPat);
}
return(returnList);
}
public StripeImageProcessor(PatternData pattern, ImageProcessor imageProcessor)
: base(pattern, imageProcessor)
{
}
private static PatternData FindTemplateRecursive(AIMLData ai, List<string> text,
PatternData data, int searchPos)
{
var key = text[searchPos];
if (data.IsInWildcard && searchPos < text.Count - 1 && !ai.Data.ContainsKey("_") &&
!ai.Data.ContainsKey(key.ToUpper()) && !ai.Data.ContainsKey("*"))
{
data.WildTexts[data.WildTexts.Count - 1].WildText += key + " ";
return FindTemplateRecursive(ai, text, data, searchPos + 1);
}
if (ai.Data.ContainsKey("_"))
{
if (searchPos == text.Count - 1)
{
data.IsAnswer = true;
data.Template = ai.Data["_"].Template;
return data;
}
data.WildTexts.Add(new WildData { WildText = key + " ", WildType = data.WildType });
data.IsInWildcard = true;
data = FindTemplateRecursive(ai.Data["_"], text, data, searchPos + 1);
if (data.IsAnswer)
return data;
data.WildTexts.RemoveAt(data.WildTexts.Count - 1);
data.WildType = data.WildTexts.Count == 0 ? StarType.Pattern :
data.WildTexts[data.WildTexts.Count - 1].WildType;
}
if (ai.Data.ContainsKey(key.ToUpper()))
{
if (searchPos == text.Count - 1)
{
data.IsAnswer = true;
data.Template = ai.Data[key.ToUpper()].Template;
return data;
}
if (key.ToUpper() == "<THAT>")
data.WildType = StarType.That;
if (key.ToUpper() == "<TOPIC>")
data.WildType = StarType.Topic;
data.IsInWildcard = false;
data = FindTemplateRecursive(ai.Data[key.ToUpper()], text, data, searchPos + 1);
if (data.IsAnswer)
return data;
}
if (!data.IsAnswer && ai.Data.ContainsKey("*"))
{
if (searchPos == text.Count - 1)
{
data.IsAnswer = true;
data.Template = ai.Data["*"].Template;
return data;
}
data.WildTexts.Add(new WildData { WildText = key + " ", WildType = data.WildType });
data.IsInWildcard = true;
data = FindTemplateRecursive(ai.Data["*"], text, data, searchPos + 1);
if (data.IsAnswer)
return data;
data.WildTexts.RemoveAt(data.WildTexts.Count - 1);
data.WildType = data.WildTexts.Count == 0 ? StarType.Pattern :
data.WildTexts[data.WildTexts.Count - 1].WildType;
}
return data;
}
private SearchResult FindNextPattern(string pattern, Path path, SnapshotPoint point, int count)
{
var patternData = new PatternData(pattern, path);
return _search.FindNextPattern(patternData, point, _wordNavigator, count);
}
