public void ChangeProgress(float NewProgress)
{
//Setting the stars active based on the amount of progress.
transform.localScale = new Vector2(NewProgress, transform.localScale.y);
progress = NewProgress;
if (progress > (1f / 3f))
{
Star1.SetActive(true);
}
else
{
Star1.SetActive(false);
}
if (progress > (2f / 3f))
{
Star2.SetActive(true);
}
else
{
Star2.SetActive(false);
}
if (progress == 1f)
{
Star3.SetActive(true);
}
else
{
Star3.SetActive(false);
}
}
public void ChangeStars()
{
//Get the amount of stars of the current level and display them
starsToDisplay = currentLevel.currentStars;
switch (starsToDisplay)
{
case 0:
Star0.SetActive(true);
break;
case 1:
Star0.SetActive(false);
Star1.SetActive(true);
break;
case 2:
Star1.SetActive(false);
Star2.SetActive(true);
break;
case 3:
Star2.SetActive(false);
Star3.SetActive(true);
break;
}
}
public static void Main(string[] args)
{
int star1 = Star1.GetMultiplyExpensesEqualsTo2020();
int star2 = Star2.GetMultiplyExpensesEqualsTo2020();
Console.WriteLine($"Star 1: { star1 }");
Console.WriteLine($"Star 2: { star2 }");
Console.ReadKey();
}
// Use this for initialization
void Start() //Mise en Place de la Scene.
{
End = GameObject.Find("End");
Star1 = GameObject.Find("1 Star");
Star2 = GameObject.Find("2 Star");
Star3 = GameObject.Find("3 Star");
Star1.SetActive(false);
Star2.SetActive(false);
Star3.SetActive(false);
Fermeture = GameObject.Find("Fermeture");
Bienjoue = GameObject.Find("BienJoué");
genial = GameObject.Find("Génial");
excellent = GameObject.Find("Excellent");
score = GameObject.Find("Score");
Fermeture.SetActive(false);
Bienjoue.SetActive(false);
genial.SetActive(false);
excellent.SetActive(false);
next = GameObject.Find("Next Level").GetComponent <Button>();
score.GetComponent <Text>().text = "Score: " + GameManager.Score.ToString();
switch (GameManager.Stars)
{
case 0:
GameObject.Find("Main Camera").GetComponent <AudioSource>().clip = bad;
GameObject.Find("Main Camera").GetComponent <AudioSource>().Play();
Fermeture.SetActive(true);
next.interactable = false;
break;
case 1:
GameObject.Find("Main Camera").GetComponent <AudioSource>().clip = applause;
GameObject.Find("Main Camera").GetComponent <AudioSource>().Play();
Bienjoue.SetActive(true);
Star1.SetActive(true);
break;
case 2:
GameObject.Find("Main Camera").GetComponent <AudioSource>().clip = applause;
GameObject.Find("Main Camera").GetComponent <AudioSource>().Play();
genial.SetActive(true);
Star1.SetActive(true);
Star2.SetActive(true);
break;
case 3:
GameObject.Find("Main Camera").GetComponent <AudioSource>().clip = applause;
GameObject.Find("Main Camera").GetComponent <AudioSource>().Play();
excellent.SetActive(true);
Star1.SetActive(true);
GameObject.Find("Canvas").GetComponent <AudioSource>().PlayOneShot(good);
Star2.SetActive(true);
Star3.SetActive(true);
break;
}
}
void Start()
{
transform = GetComponent <RectTransform> ();
width = transform.rect.width;
frame = GameObject.Find("Frame").GetComponent <RectTransform> ();
Star1 = GameObject.Find("Star1");
Star1.SetActive(false);
Star2 = GameObject.Find("Star2");
Star2.SetActive(false);
Star3 = GameObject.Find("Star3");
Star3.SetActive(false);
}
private void Start()
{
if (ReciverManager.Instance.StarRecived == 2)
{
Star3.GetComponentInChildren <Image>().sprite = LostStarSprite;
}
if (ReciverManager.Instance.StarRecived == 1)
{
Star2.GetComponentInChildren <Image>().sprite = LostStarSprite;
Star3.GetComponentInChildren <Image>().sprite = LostStarSprite;
}
MessageText.text = ReciverManager.Instance.Msg.GetMessage();
}
public void OnContinueClicked()
{
HidePopup();
StartCoroutine(DeActivate(1f, () => { if (ContinueClicked != null)
{
ContinueClicked();
}
}));
AudioManager.Instance.PlaySound(AudioManager.SFX.CLICK);
StarsPanel.SetActive(false);
Star1.SetActive(false);
Star2.SetActive(false);
Star3.SetActive(false);
}
public override void Draw(SpriteBatch spriteBatch)
{
base.Draw(spriteBatch);
AlignText(WinningText, Alignment.Center, 25);
AlignText(ScoreText, Alignment.Center, 175);
ScoreText.Text = DisplayedScore.ToString("N0");
WinningText.Draw(spriteBatch);
ScoreText.Draw(spriteBatch);
RestartButton.Draw(spriteBatch);
NextButton.Draw(spriteBatch);
Star1.Draw(spriteBatch);
Star2.Draw(spriteBatch);
Star3.Draw(spriteBatch);
}
void OutputStar()
{
if (PlayerPrefs.GetInt("Score") < 6)
{
}
if (PlayerPrefs.GetInt("Score") > 6 && PlayerPrefs.GetInt("Score") < 12)
{
Star1.SetActive(true);
}
if (PlayerPrefs.GetInt("Score") > 12 && PlayerPrefs.GetInt("Score") < 20)
{
Star1.SetActive(true);
Star2.SetActive(true);
}
if (PlayerPrefs.GetInt("Score") > 20)
{
Star1.SetActive(true);
Star2.SetActive(true);
Star3.SetActive(true);
}
}
IEnumerator ShowStars(int starsCount)
{
yield return(new WaitForSeconds(1f));
if (starsCount >= 1)
{
Star1.SetActive(true);
AudioManager.Instance.PlaySound(AudioManager.SFX.STAR);
yield return(new WaitForSeconds(0.5f));
}
if (starsCount >= 2)
{
Star2.SetActive(true);
AudioManager.Instance.PlaySound(AudioManager.SFX.STAR);
yield return(new WaitForSeconds(0.5f));
}
if (starsCount >= 3)
{
Star3.SetActive(true);
AudioManager.Instance.PlaySound(AudioManager.SFX.STAR);
}
}
public void Configure(int StarAchieved)
{
Star1.SetActive(StarAchieved >= 1);
Star2.SetActive(StarAchieved >= 2);
Star3.SetActive(StarAchieved >= 3);
}
public static MulticlassSupportVectorMachine <Gaussian> Train(Dictionary <TagType, List <List <double[]> > > allsignalsList)
{
int seed = DateTime.Now.Second;
_xrand = new Random(seed);
Console.WriteLine("a entrenar se ha dicho");
List <double[]> inputsList = new List <double[]>();
List <int> outputsList = new List <int>();
foreach (var tag in allsignalsList.Keys)
{
Console.WriteLine($"empezando pro el tag {tag}");
int i = 0;
foreach (var signalList in allsignalsList[tag])
{
double[] featureVector = PreProcess(signalList,
0.99,
EEGEmoProc2ChSettings.Instance.m.Value,
EEGEmoProc2ChSettings.Instance.r.Value,
EEGEmoProc2ChSettings.Instance.N.Value,
1,
0).ToArray();
inputsList.Add(featureVector);
outputsList.Add(tag.GetHashCode());
i = i + 1;
Console.WriteLine($"ya van {i} listas del tag {tag}");
}
}
Console.WriteLine("procesado todo, ahora a buscar");
// Instantiate a new Grid Search algorithm for Kernel Support Vector Machines
int iterationsMax = 7;
double minError = 0.1;
int maxPopulation = 3;
MulticlassSupportVectorMachine <Gaussian> svm = null; // Training(inputsList, outputsList).BestModel;
Tuple <MulticlassSupportVectorMachine <Gaussian>, double, double, double> result = null; // Training(inputsList, outputsList);
//svm = result.BestModel;
string internalDirectory = _dataAccessFacade.GetGeneralSettings().GetModalDirectory("Emotion");
var file_all_models = File.AppendText(Path.Combine(internalDirectory, "all_models.txt"));
var file_all_stars = File.AppendText(Path.Combine(internalDirectory, "all_stars_all_its.txt"));
result = Training(inputsList, outputsList);
Star2[] stars = new Star2[maxPopulation];
Star2 best = new Star2()
{
svm = result.Item1.DeepClone(),
error = result.Item2,
Complexity = result.Item3,
Gamma = result.Item4,
inputsList = inputsList
};
//inicialization
for (int iStar = 0; iStar < maxPopulation; iStar++)
{
stars[iStar] = new Star2()
{
svm = result.Item1.DeepClone(),
error = result.Item2,
Complexity = result.Item3,
Gamma = result.Item4,
inputsList = inputsList
};
try
{
for (int iInput = 0; iInput < stars[iStar].inputsList.Count; iInput++)
{
for (int jinput = 0; jinput < stars[iStar].inputsList[iInput].Length; jinput++)
{
stars[iStar].inputsList[iInput][jinput] = stars[iStar].inputsList[iInput][jinput]
+ ((_xrand.NextDouble() * -1) * result.Item2 * stars[iStar].inputsList[iInput][jinput]);
}
}
var res = Training(stars[iStar].inputsList, outputsList);
stars[iStar].svm = res.Item1;
stars[iStar].error = res.Item2;
stars[iStar].Complexity = res.Item3;
stars[iStar].Gamma = res.Item4;
}catch (Exception ex)
{
Console.WriteLine("Error al inicializar estrella " + iStar + ": " + ex.Message);
}
}
foreach (var star in stars)
{
if (star.error < best.error)
{
best = star;
}
}
//cycle
for (int i = 0; i < iterationsMax; i++)
{
file_all_models.WriteLine($"Model: {i}, Seed: {seed}, Error: {best.error}, Gamma: {best.Gamma}, C: {best.Complexity}\n inputs: {best.inputsList.ToJsonString(true)}");
file_all_models.Flush();
if (best.error < minError)
{
svm = best.svm;
WriteFiles(best.error, best.Gamma, best.Complexity, best.inputsList, outputsList, best.svm);
return(svm);
}
//each star
for (int iStar = 0; iStar < stars.Length; iStar++)
{
Star2 prevStar = stars[iStar];
try
{
for (int iInput = 0; iInput < stars[iStar].inputsList.Count; iInput++)
{
for (int jinput = 0; jinput < stars[iStar].inputsList[iInput].Length; jinput++)
{
stars[iStar].inputsList[iInput][jinput] = stars[iStar].inputsList[iInput][jinput]
+ _xrand.NextDouble()
* (best.inputsList[iInput][jinput] - stars[iStar].inputsList[iInput][jinput]);
}
}
var res = Training(stars[iStar].inputsList, outputsList);
stars[iStar].svm = res.Item1;
stars[iStar].error = res.Item2;
stars[iStar].Complexity = res.Item3;
stars[iStar].Gamma = res.Item4;
file_all_stars.WriteLine($"Model: {i}, Seed: {seed}, Error: {stars[iStar].error}, Gamma: {stars[iStar].Gamma}, C: {stars[iStar].Complexity}\n inputs: {stars[iStar].inputsList.ToJsonString(true)}");
file_all_stars.Flush();
}
catch (Exception ex)
{
Console.WriteLine("Error en it " + i + " al cambiar estrella " + iStar + ": " + ex.Message);
stars[iStar] = prevStar;
}
}
foreach (var star in stars)
{
if (star.error < best.error)
{
best = star;
}
}
svm = best.svm;
}
file_all_models.Close();
file_all_stars.Close();
WriteFiles(result.Item2, result.Item3, result.Item4, inputsList, outputsList, result.Item1);
return(svm);
}
void Update()
{
if (showScoreCircles && CameraManager.cameraAdjusted)
{
if (ang < maxAng)
{
ang += Time.deltaTime * 300;
}
else
{
ang = maxAng;
}
levelSquare.transform.localRotation = Quaternion.AngleAxis(ang, Vector3.back);
UpdatePlatformObjectProperties(currentScoreCircle, currentScoreCirclePos, 1f, true, true);
UpdatePlatformObjectProperties(prevScoreCircleFar, prevScoreCircleFarPos, circleAlphaFar, true, true);
UpdatePlatformObjectProperties(prevScoreCircleNear, prevScoreCircleNearPos, circleAlphaNear, true, true);
UpdatePlatformObjectProperties(nextScoreCircleNear, nextScoreCircleNearPos, circleAlphaNear, true, true);
UpdatePlatformObjectProperties(nextScoreCircleFar, nextScoreCircleFarPos, circleAlphaFar, true, true);
UpdatePlatformObjectProperties(hintButton, hintButtonPos, 1f, true, false);
UpdatePlatformObjectProperties(timerCircle3Star, timerCircle3Pos, 1f, false, false);
UpdatePlatformObjectProperties(timerCircle2Star, timerCircle2Pos, 1f, false, false);
UpdatePlatformObjectProperties(timerCircle1Star, timerCircle1Pos, 1f, false, false);
if (prevScoreCircleFar.transform.localPosition == prevScoreCircleFarPos)
{
showScoreCircles = false;
}
}
if (WaitForHintFlag && !waitingFlag)
{
if (score == 0 || score == 1)
{
StartCoroutine(WaitForHint(2.0f));
}
else
{
StartCoroutine(WaitForHint(1.0f));
}
}
if (ShowHintScreenFlag)
{
hintScreen.transform.localScale = Vector3.Lerp(hintScreen.transform.localScale, hintScreenSize, circleSpeed * Time.deltaTime);
}
if (HideHintScreenFlag)
{
hintScreen.transform.localScale = Vector3.Lerp(hintScreen.transform.localScale, hintScreenCollapseSize, circleSpeed * Time.deltaTime);
}
if (StartTimerFlag && !PauseTimerFlag)
{
if (!timerSlider.activeSelf)
{
timerSlider.SetActive(true);
homeButton.SetActive(false);
pauseButton.SetActive(true);
}
float currTime = TimeManager.GetCurrentTime() - pauseDuration;
if (currTime < TimeManager.time3star)
{
timerStartCounter3 += Time.deltaTime / TimeManager.time3star;
timerSlider.transform.localPosition = Vector3.Lerp(timerSliderInitPos, timerCircle3Star.transform.localPosition, timerStartCounter3);
timerSlider.GetComponent <SpriteRenderer> ().color = colourDict ["TimerColour3Star"];
}
else if (currTime < TimeManager.time2star)
{
timerStartCounter2 += Time.deltaTime / (TimeManager.time2star - TimeManager.time3star);
timerSlider.transform.localPosition = Vector3.Lerp(timerCircle3Star.transform.localPosition, timerCircle2Star.transform.localPosition, timerStartCounter2);
timerSlider.GetComponent <SpriteRenderer> ().color = colourDict ["TimerColour2Star"];
timerCircle3Star.GetComponent <SpriteRenderer> ().color = colourDict ["TimerColourOff"];
timerCircle3Star.GetComponentInChildren <Text> ().text = "";
}
else if (currTime < TimeManager.time1star)
{
timerStartCounter1 += Time.deltaTime / (TimeManager.time1star - TimeManager.time2star);
timerSlider.transform.localPosition = Vector3.Lerp(timerCircle2Star.transform.localPosition, timerCircle1Star.transform.localPosition, timerStartCounter1);
timerSlider.GetComponent <SpriteRenderer> ().color = colourDict ["TimerColour1Star"];
timerCircle2Star.GetComponent <SpriteRenderer> ().color = colourDict ["TimerColourOff"];
timerCircle2Star.GetComponentInChildren <Text> ().text = "";
timerCircle3Star.GetComponent <SpriteRenderer> ().color = colourDict ["TimerColourOff"];
timerCircle3Star.GetComponentInChildren <Text> ().text = "";
}
else
{
timerCircle2Star.GetComponent <SpriteRenderer> ().color = colourDict ["TimerColourOff"];
timerCircle2Star.GetComponentInChildren <Text> ().text = "";
timerCircle3Star.GetComponent <SpriteRenderer> ().color = colourDict ["TimerColourOff"];
timerCircle3Star.GetComponentInChildren <Text> ().text = "";
}
}
if (ScoreCompleteFlag)
{
UpdatePlatformObjectProperties(prevScoreCircleFar, currentScoreCirclePos, 0f, true, true);
UpdatePlatformObjectProperties(prevScoreCircleNear, currentScoreCirclePos, 0f, true, true);
UpdatePlatformObjectProperties(nextScoreCircleNear, currentScoreCirclePos, 0f, true, true);
UpdatePlatformObjectProperties(nextScoreCircleFar, currentScoreCirclePos, 0f, true, true);
Color newColor = Color.Lerp(currentScoreCircle.GetComponent <SpriteRenderer> ().color, LevelColour, alphaSpeed * Time.deltaTime);
currentScoreCircle.GetComponent <SpriteRenderer> ().color = newColor;
currentScoreCircle.GetComponentInChildren <Text> ().color = newColor;
if (prevScoreCircleFar.transform.localPosition == currentScoreCircle.transform.localPosition)
{
print("SCORE COMPLETED.....");
//Flip tiles to show menu items
flipTilesFlag = true;
ScoreCompleteFlag = false;
HintEnabled = false;
CameraManager.ZoomInPlatform();
homeButton.SetActive(true);
pauseButton.SetActive(false);
}
}
//Flip tiles to show Menu
if (flipTilesFlag)
{
FlipTilesAndShowMenu();
}
//Show Menu Screen
if (ShowStarsFlag)
{
if (!TimeTakenShown)
{
TimeTakenObj = Instantiate(TimeTakenText, transform);
TimeTakenObj.transform.position = Star2.transform.position + new Vector3(0, 2, 0);
TimeTakenObj.GetComponentInChildren <Text> ().text = "Completed in " + TimeManager.GetTimeTaken() + "s.";
TimeTakenShown = true;
}
Quaternion _targetRotation = Quaternion.Euler(new Vector3(0, 0, 180));
if (myStar >= 1 && !Star1RotCompleteFlag)
{
Star1.GetComponent <SpriteRenderer>().color = Color.Lerp(Star1.GetComponent <SpriteRenderer> ().color, colourDict ["StarColour"], alphaSpeed * Time.deltaTime);
Star1.transform.localRotation = Quaternion.Lerp(Star1.transform.localRotation, _targetRotation, 10 * Time.deltaTime);
Star1.transform.localScale = Vector3.Lerp(Star1.transform.localScale, new Vector3(0.6f, 0.6f, 0.6f), 10 * Time.deltaTime);
if (Star1.transform.localRotation == _targetRotation)
{
Star1RotCompleteFlag = true;
}
}
if (myStar >= 2 && !Star2RotCompleteFlag && Star1RotCompleteFlag)
{
Star2.GetComponent <SpriteRenderer>().color = Color.Lerp(Star2.GetComponent <SpriteRenderer> ().color, colourDict ["StarColour"], alphaSpeed * Time.deltaTime);
Star2.transform.localRotation = Quaternion.Lerp(Star2.transform.localRotation, _targetRotation, 10 * Time.deltaTime);
Star2.transform.localScale = Vector3.Lerp(Star2.transform.localScale, new Vector3(0.6f, 0.6f, 0.6f), 10 * Time.deltaTime);
if (Star2.transform.localRotation == _targetRotation)
{
Star2RotCompleteFlag = true;
}
}
if (myStar >= 3 && !Star3RotCompleteFlag && Star2RotCompleteFlag)
{
Star3.GetComponent <SpriteRenderer>().color = Color.Lerp(Star3.GetComponent <SpriteRenderer> ().color, colourDict ["StarColour"], alphaSpeed * Time.deltaTime);
_targetRotation = Quaternion.Euler(new Vector3(0, 0, 180));
Star3.transform.localRotation = Quaternion.Lerp(Star3.transform.localRotation, _targetRotation, 10 * Time.deltaTime);
Star3.transform.localScale = Vector3.Lerp(Star3.transform.localScale, new Vector3(0.6f, 0.6f, 0.6f), 10 * Time.deltaTime);
if (Star3.transform.localRotation == _targetRotation)
{
Star3RotCompleteFlag = true;
}
}
if ((myStar == 1 && Star1RotCompleteFlag) || (myStar == 2 && Star2RotCompleteFlag) || (myStar == 3 && Star3RotCompleteFlag))
{
ShowStarsFlag = false;
}
}
//Retry enabled
if (RetryPlatformFlag)
{
UpdatePlatformObjectProperties(prevScoreCircleFar, prevScoreCircleFarPos, circleAlphaFar, true, true);
UpdatePlatformObjectProperties(prevScoreCircleNear, prevScoreCircleNearPos, circleAlphaNear, true, true);
UpdatePlatformObjectProperties(nextScoreCircleNear, nextScoreCircleNearPos, circleAlphaNear, true, true);
UpdatePlatformObjectProperties(nextScoreCircleFar, nextScoreCircleFarPos, circleAlphaFar, true, true);
timerCircle3Star.GetComponent <SpriteRenderer> ().color = colourDict ["TimerColour3Star"];
timerCircle2Star.GetComponent <SpriteRenderer> ().color = colourDict ["TimerColour2Star"];
timerCircle1Star.GetComponent <SpriteRenderer> ().color = colourDict ["TimerColour1Star"];
timerCircle3Star.GetComponentInChildren <Text> ().text = transform.GetComponent <TimeManager> ().time3star.ToString() + " s";
timerCircle2Star.GetComponentInChildren <Text> ().text = transform.GetComponent <TimeManager> ().time2star.ToString() + " s";
timerCircle1Star.GetComponentInChildren <Text> ().text = transform.GetComponent <TimeManager> ().time1star.ToString() + " s";
if (prevScoreCircleFar.transform.localPosition == prevScoreCircleFarPos)
{
RetryPlatformFlag = false;
}
}
}
void OnCollisionEnter2D(Collision2D col) //col ==> trou ;;//gameobject --> object qui est en collision avec les trous, on attache ce script à grain et nn trou
{
if (gameObject.CompareTag("arrosoir") && col.gameObject.CompareTag("trou1") && PelleToTrou.pelle1Done == true && GrainToTrou.grain1Done == true)
{
myAnim = Instantiate(prefabAnim, col.transform.position, transform.rotation); // initiate dans la pos du trou
Destroy(myAnim, 2.0f);
RegenererGameObject();
Destroy(this.gameObject); //l'ordre compte, il faut regenerer tout d'abord, après destroy
if (col.gameObject.CompareTag("trou1"))
{
action3 = true;
ScoreCounter.score += 2;
InstantiatePlusTwoAnim();
}
}
if (GrainLevel2.action2Tr3 == true && gameObject.CompareTag("arrosoir") && col.gameObject.CompareTag("trou3"))
{
myAnim = Instantiate(prefabAnim, col.transform.position, transform.rotation); // initiate dans la pos du trou
Destroy(myAnim, 2.0f);
RegenererGameObject();
Destroy(this.gameObject); //l'ordre compte, il faut regenerer tout d'abord, après destroy
if (col.gameObject.CompareTag("trou3"))
{
action3Tr3 = true;
ScoreCounter.score += 2;
InstantiatePlusTwoAnim();
//on montre la 1ere etoile
StarOne.showStarOne();
star1L2 = true;
}
}
if (GrainLevel2.action2Tr4 == true && gameObject.CompareTag("arrosoir") && col.gameObject.CompareTag("trou4"))
{
myAnim = Instantiate(prefabAnim, col.transform.position, transform.rotation); // initiate dans la pos du trou
Destroy(myAnim, 2.0f);
RegenererGameObject();
Destroy(this.gameObject); //l'ordre compte, il faut regenerer tout d'abord, après destroy
if (col.gameObject.CompareTag("trou4"))
{
action3Tr4 = true;
ScoreCounter.score += 2;
InstantiatePlusTwoAnim();
Star2.showStar2();
star2L2 = true;
}
}
if (gameObject.CompareTag("arrosoir") && col.gameObject.CompareTag("trou5") && Trou4Level2.grainTrou5 == true)
{
myAnim = Instantiate(prefabAnim, col.transform.position, transform.rotation); // initiate dans la pos du trou
Destroy(myAnim, 2.0f);
RegenererGameObject();
Destroy(this.gameObject); //l'ordre compte, il faut regenerer tout d'abord, après destroy
if (col.gameObject.CompareTag("trou5"))
{
action3Tr5 = true;
ScoreCounter.score += 2;
InstantiatePlusTwoAnim();
star3.showStar3();
star3L2 = true;
}
}
}
public MulticlassSupportVectorMachine <Gaussian> Train(Dictionary <TagType, List <List <double[]> > > allsignalsList)
{
int seed = DateTime.Now.Second + DateTime.Now.Millisecond + DateTime.Now.Minute;
Console.WriteLine("semilla: " + seed);
_xrand = new Random(seed);
Console.WriteLine("a entrenar se ha dicho");
List <double[]> inputsList = new List <double[]>();
List <int> outputsList = new List <int>();
_originputsList = new List <double[]>();
_originalInputsList = new List <Tuple <double[], int> >();
foreach (var tag in allsignalsList.Keys)
{
Console.WriteLine("empezando a procesar el tag:" + tag);
int i = 0;
foreach (var signalList in allsignalsList[tag])
{
double[] featureVector = PreProcess(signalList,
0.99,
EEGEmoProc2ChSettings.Instance.m.Value,
EEGEmoProc2ChSettings.Instance.r.Value,
EEGEmoProc2ChSettings.Instance.N.Value,
20,
0).ToArray();
inputsList.Add(featureVector.DeepClone());
_originputsList.Add(featureVector.DeepClone());
outputsList.Add(tag.DeepClone().GetHashCode());
_originalInputsList.Add(new Tuple <double[], int>(featureVector.DeepClone(), tag.DeepClone().GetHashCode()));
//Console.WriteLine(_originalInputsList[i].Item1+","+ _originalInputsList[i].Item2);
i = i + 1;
}
}
Console.WriteLine("procesado todo, ahora a buscar");
bool randomInitial = EEGEmoProc2ChSettings.Instance.RandomInitialFeatures.Value;
if (randomInitial)
{
double minInput = double.PositiveInfinity;
double maxInput = double.NegativeInfinity;
for (int iInput = 0; iInput < inputsList.Count; iInput++)
{
for (int jInput = 0; jInput < inputsList[iInput].Length; jInput++)
{
if (minInput > inputsList[iInput][jInput])
{
minInput = inputsList[iInput][jInput];
}
if (maxInput < inputsList[iInput][jInput])
{
maxInput = inputsList[iInput][jInput];
}
}
}
for (int iInput = 0; iInput < inputsList.Count; iInput++)
{
for (int jInput = 0; jInput < inputsList[iInput].Length; jInput++)
{
inputsList[iInput][jInput] = _xrand.NextDouble() * (maxInput - minInput + 1) + minInput;
}
}
}
bool onlyPaper = EEGEmoProc2ChSettings.Instance.OnlyPaper.Value;
if (onlyPaper)
{
var res = TrainingPaper(inputsList, outputsList);
WriteFiles(res.Item2, res.Item4, res.Item3, _originputsList, outputsList, res.Item1);
return(res.Item1);
}
// Instantiate a new Grid Search algorithm for Kernel Support Vector Machines
MulticlassSupportVectorMachine <Gaussian> svm = null; // Training(inputsList, outputsList).BestModel;
Tuple <MulticlassSupportVectorMachine <Gaussian>, double, double, double> result; // Training(inputsList, outputsList);
var fileBestByIt = File.AppendText(Path.Combine(_directory, "historial_best_by_it.txt"));
var file_all_stars = File.AppendText(Path.Combine(_directory, "all_stars_all_its.txt"));
Star2[] stars = new Star2[_population];
Star2 best;
try
{
result = Training(inputsList, outputsList);
best = new Star2()
{
svm = result.Item1.DeepClone(),
error = result.Item2,
Complexity = result.Item3,
Gamma = result.Item4,
inputsList = inputsList.DeepClone()
};
}
catch (Exception ex)
{
Console.WriteLine("Error al entrenar el primero: " + ex.Message + "\nInner: " + ex.InnerException?.Message);
best = new Star2()
{
svm = null,
error = 1,
Complexity = -1,
Gamma = -1,
inputsList = inputsList.DeepClone()
};
}
fileBestByIt.WriteLine("Iteration: Initial model, Seed: " + seed + ", Error: " + best.error + ", Gamma: " + best.Gamma + ", C: " + best.Complexity + "\n inputs: " + best.inputsList.ToJsonString(true));
fileBestByIt.Flush();
file_all_stars.WriteLine("Model: inicial, Seed: " + seed + ", Error: " + best.error + ", Gamma: " + best.Gamma + ", C: " + best.Complexity + "\n inputs: " + best.inputsList.ToJsonString(true));
file_all_stars.Flush();
//inicialization
for (int iStar = 0; iStar < stars.Length; iStar++)
{
stars[iStar] = new Star2()
{
svm = best.svm?.DeepClone(),
error = best.error,
Complexity = best.Complexity,
Gamma = best.Gamma,
inputsList = inputsList.DeepClone()
};
try
{
for (int iInput = 0; iInput < stars[iStar].inputsList.Count; iInput++)
{
for (int jinput = 0; jinput < stars[iStar].inputsList[iInput].Length; jinput++)
{
stars[iStar].inputsList[iInput][jinput] = stars[iStar].inputsList[iInput][jinput]
+ ((_xrand.NextDouble() * -1) * stars[iStar].error * stars[iStar].inputsList[iInput][jinput]);
}
}
var res = Training(stars[iStar].inputsList, outputsList);
stars[iStar].svm = res.Item1;
stars[iStar].error = res.Item2;
stars[iStar].Complexity = res.Item3;
stars[iStar].Gamma = res.Item4;
file_all_stars.WriteLine("Model: -1, Seed: " + seed + ", Error: " + stars[iStar].error + ", Gamma: " + stars[iStar].Gamma + ", C: " + stars[iStar].Complexity + "\n inputs: " + stars[iStar].inputsList.ToJsonString(true));
file_all_stars.Flush();
}
catch (Exception ex)
{
Console.WriteLine("Error al inicializar estrella " + iStar + ": " + ex.Message + "\nInner: " + ex.InnerException?.Message);
}
}
foreach (var star in stars)
{
if (star.error < best.error)
{
best.svm = star.svm?.DeepClone();
best.error = star.error;
best.Complexity = star.Complexity;
best.Gamma = star.Gamma;
best.inputsList = star.inputsList.DeepClone();
}
}
//cycle
for (int i = 0; i < _iterations; i++)
{
Console.WriteLine("-----------------------------------------------------------------------------------------------");
Console.WriteLine("Iteration: " + i + ", Seed" + seed + ", Error: " + best.error);
Console.WriteLine("-----------------------------------------------------------------------------------------------");
fileBestByIt.WriteLine("Iteration: " + i + ", Seed: " + seed + ", Error: " + best.error + ", Gamma: " + best.Gamma + ", C: " + best.Complexity + "\n inputs: " + best.inputsList.ToJsonString(true));
fileBestByIt.Flush();
if (best.error <= _minError)
{
svm = best.svm;
WriteFiles(best.error, best.Gamma, best.Complexity, best.inputsList, outputsList, best.svm);
return(svm);
}
//each star
for (int iStar = 0; iStar < stars.Length; iStar++)
{
Star2 prevStar = new Star2()
{
svm = stars[iStar].svm?.DeepClone(),
error = stars[iStar].error,
Complexity = stars[iStar].Complexity,
Gamma = stars[iStar].Gamma,
inputsList = stars[iStar].inputsList.DeepClone()
};
try
{
for (int iInput = 0; iInput < stars[iStar].inputsList.Count; iInput++)
{
for (int jinput = 0; jinput < stars[iStar].inputsList[iInput].Length; jinput++)
{
stars[iStar].inputsList[iInput][jinput] = stars[iStar].inputsList[iInput][jinput]
+ _xrand.NextDouble()
* (best.inputsList[iInput][jinput] - stars[iStar].inputsList[iInput][jinput]);
}
}
var res = Training(stars[iStar].inputsList, outputsList);
stars[iStar].svm = res.Item1;
stars[iStar].error = res.Item2;
stars[iStar].Complexity = res.Item3;
stars[iStar].Gamma = res.Item4;
file_all_stars.WriteLine("it: " + i + ", Model: " + iStar + " Seed: " + seed + ", Error: " + stars[iStar].error + ", Gamma: " + stars[iStar].Gamma + ", C: " + stars[iStar].Complexity + "\n inputs: " + stars[iStar].inputsList.ToJsonString(true));
file_all_stars.Flush();
}
catch (Exception ex)
{
Console.WriteLine("Error en it " + i + " al cambiar estrella " + iStar + ": " + ex.Message + "\n Inner: " + ex.InnerException?.Message);
stars[iStar] = prevStar;
}
}
for (int iStar = 0; iStar < stars.Length; iStar++)
{
if (stars[iStar].error < best.error)
{
best.svm = stars[iStar].svm?.DeepClone();
best.error = stars[iStar].error;
best.Complexity = stars[iStar].Complexity;
best.Gamma = stars[iStar].Gamma;
best.inputsList = stars[iStar].inputsList.DeepClone();
}
double sumError = 0;
for (int jStar = 0; jStar < stars.Length; jStar++)
{
sumError += stars[jStar].error;
}
if ((best.error / sumError) < _xrand.NextDouble() * 0.05)
{
Console.WriteLine("Se alcanzó el horizonte de eventos en " + iStar);
for (int iInput = 0; iInput < stars[iStar].inputsList.Count; iInput++)
{
for (int jinput = 0; jinput < stars[iStar].inputsList[iInput].Length; jinput++)
{
stars[iStar].inputsList[iInput][jinput] = stars[iStar].inputsList[iInput][jinput]
+ ((_xrand.NextDouble() * -1) * stars[iStar].error * stars[iStar].inputsList[iInput][jinput]);
}
}
}
}
svm = best.svm;
}
fileBestByIt.Close();
file_all_stars.Close();
WriteFiles(best.error, best.Gamma, best.Complexity, _originputsList, outputsList, best.svm);
return(svm);
}
public void countPoints()
{
Time.timeScale = 0; //Pausa spelet och tiden
int numSaved = 0;
Points += timeFactor * countdownScript.getTimeLeft();
victims = GameObject.FindGameObjectsWithTag("Victim");
foreach (GameObject victim in victims)
{
victimParam = victim.GetComponent <Parameters>();
Dictionary <string, object> ParamDic = victimParam.getParamHash();
if ((string)ParamDic["SetPrio"] == "unset")
{
Points -= unSetTriagePenelty;
}
else if ((string)ParamDic["SetPrio"] == ParamDic["prio"].ToString().ToLower())
{
Debug.Log("Correct");
numSaved += 1;
Points += correctTriagePoint;
}
else if ((string)ParamDic["SetPrio"] != ParamDic["prio"].ToString().ToLower())
{
Debug.Log("incorrect");
Points -= incorrectTriagePenelty;
}
if ((bool)ParamDic["Bleeding"] == true)
{
Debug.Log("Bleeding");
Points -= incorrectTriagePenelty;
}
//Debug.Log(ParamDic["prio"]+" : "+ParamDic["SetPrio"]);
}
foreach (GameObject item in GameOverList)
{
item.SetActive(true);
}
//Behöver göras dynamisk när vi har fler levels
if (Points <= 0)
{
PointRatio = 0;
}
else
{
PointRatio = Points; //Kvot för nuv. poäng genom tot. möjliga poäng * 100
}
PointsTxt.text = PointRatio.ToString();
LevelTxt.text = "1";
int starCapPoint = victims.Length * correctTriagePoint;
Debug.Log(PointRatio + " : " + starCapPoint);
if (PointRatio > starCapPoint * 0.25f)
{
Star1.SetActive(true);
}
if (PointRatio > starCapPoint * 0.5f)
{
Star2.SetActive(true);
}
if (PointRatio >= starCapPoint)
{
Star3.SetActive(true);
}
}
void OnCollisionEnter2D(Collision2D col) //col ==> trou ;;//gameobject --> object qui est en collision avec les trous, on attache ce script à grain et nn trou
{
if (DDCreuser.action1 == true && DDGrain.action2 == true && gameObject.CompareTag("arrosoir"))
{
InstantiatePrefab(col.transform.position);
RegenererGameObject();
Destroy(this.gameObject); //l'ordre compte, il faut regenerer tout d'abord, après destroy
if (col.gameObject.CompareTag("trou1"))
{
action3 = true;
ScoreCounter.score += 1;
InstantiatePlusOneAnim();
}
}
if (DDCreuser.action1Tr2 == true && DDGrain.action2Tr2 == true && gameObject.CompareTag("arrosoir"))
{
if (ScoreCounter.score > 5)
{
isColliding = true;
return;
}
InstantiatePrefab(col.transform.position);
RegenererGameObject();
Destroy(this.gameObject); //l'ordre compte, il faut regenerer tout d'abord, après destroy
if (col.gameObject.CompareTag("trou2"))
{
action3Tr2 = true;
ScoreCounter.score += 1;
InstantiatePlusOneAnim();
}
}
if (DDCreuser.action1Tr3 == true && DDGrain.action2Tr3 == true && gameObject.CompareTag("arrosoir"))
{
if (ScoreCounter.score > 8)
{
isColliding = true;
return;
}
InstantiatePrefab(col.transform.position);
RegenererGameObject();
Destroy(this.gameObject); //l'ordre compte, il faut regenerer tout d'abord, après destroy
if (col.gameObject.CompareTag("trou3"))
{
action3Tr3 = true;
ScoreCounter.score += 1;
InstantiatePlusOneAnim();
//on montre la 1ere etoile
StarOne.showStarOne();
star1L1 = true;
}
}
if (DDCreuser.action1Tr4 == true && DDGrain.action2Tr4 == true && gameObject.CompareTag("arrosoir"))
{
if (ScoreCounter.score > 11)
{
isColliding = true;
return;
}
InstantiatePrefab(col.transform.position);
RegenererGameObject();
Destroy(this.gameObject); //l'ordre compte, il faut regenerer tout d'abord, après destroy
if (col.gameObject.CompareTag("trou4"))
{
action3Tr4 = true;
ScoreCounter.score += 1;
InstantiatePlusOneAnim();
}
}
if (DDCreuser.action1Tr5 == true && DDGrain.action2Tr5 == true && gameObject.CompareTag("arrosoir"))
{
if (ScoreCounter.score > 14)
{
isColliding = true;
return;
}
InstantiatePrefab(col.transform.position);
RegenererGameObject();
Destroy(this.gameObject); //l'ordre compte, il faut regenerer tout d'abord, après destroy
if (col.gameObject.CompareTag("trou5"))
{
action3Tr5 = true;
ScoreCounter.score += 1;
InstantiatePlusOneAnim();
}
}
if (DDCreuser.action1Tr6 == true && DDGrain.action2Tr6 == true && gameObject.CompareTag("arrosoir"))
{
if (ScoreCounter.score > 17)
{
isColliding = true;
return;
}
InstantiatePrefab(col.transform.position);
RegenererGameObject();
Destroy(this.gameObject); //l'ordre compte, il faut regenerer tout d'abord, après destroy
if (col.gameObject.CompareTag("trou6"))
{
action3Tr6 = true;
ScoreCounter.score += 1;
InstantiatePlusOneAnim();
//la plante6 pousse on le donne une 2 eme etoile
Star2.showStar2();
star2L1 = true;
youWin.SetActive(true);
Debug.Log(star2L1);
}
}
else
{
isColliding = true;
}
}
