static private void CreateSkillStats(StatsHolder statsHolder)
{
TextAsset csvText = (TextAsset)AssetDatabase.LoadAssetAtPath(DATABASE_FOLDER + "/CSV/database - skill.csv", typeof(TextAsset));
CSVFile csvFile = new CSVFile(csvText.text);
AssetDatabase.CreateFolder(DATABASE_FOLDER + "/Asset", "Skill");
int csvCount = csvFile.length;
for (int i = 0; i < csvCount; i++)
{
string id = csvFile.Get <string>(i, "ID");
if (string.IsNullOrEmpty(id))
{
continue;
}
SkillStats c_prefab = ScriptableObjectUtility.CreateAsset <SkillStats>(DATABASE_FOLDER + "/Asset/Skill/", "[SkillStat] " + id);
EditorUtility.SetDirty(c_prefab);
c_prefab.id = id;
c_prefab.label = csvFile.Get <string>(i, "Label");
c_prefab.parameter_1 = csvFile.Get <float>(i, "Parameter 1");
c_prefab.parameter_2 = csvFile.Get <float>(i, "Parameter 2");
c_prefab.parameter_3 = csvFile.Get <float>(i, "Parameter 3");
c_prefab.parameter_4 = csvFile.Get <float>(i, "Parameter 4");
statsHolder.stpObjectHolder.Add(c_prefab);
}
}
public void AddEnemy(StatsHolder enemy)
{
if (this.enemies != null)
{
this.enemies.Add(enemy);
}
}
public static StatsHolder Minion()
{
StatsHolder stats = new StatsHolder("Minion", 2.0f, 0.5f, 1.0f, 0.5f, 0.5f, Color.black);
stats.requiredKill = false;
return(stats);
}
private void Start()
{
stats = GetComponent <StatsHolder>();
stats.OnZeroHealth = OnDeath;
weapsys = GetComponent <WeaponSystem>();
}
private void Start()
{
stats = GetComponent <StatsHolder>();
stats.OnZeroHealth = OnDeath;
GameManager.instance.enemiesCounter++;
}
public static StatsHolder RangedSpawner()
{
StatsHolder stats = new StatsHolder("Mad Spawner", 10.0f, 1.0f, 3.0f, 400.0f, 3.0f, Color.grey);
stats.attackDelay = 0.6f;
stats.projectile = RangedCirclingMinon();
return(stats);
}
public static StatsHolder SmallBomber()
{
StatsHolder stats = new StatsHolder("Small Bomber", 1.5f, 7.5f, 0.1f, 0.1f, 1.0f, new Color(1.0f, 0.6f, 0.2f, 1.0f));
stats.angularSpeed = 20f;
stats.selfDestruct = true;
return(stats);
}
public static StatsHolder RangedCirclingMinon()
{
StatsHolder stats = new StatsHolder("CirclingMinion", 4.0f, 2.0f, 1.4f, 10.0f, 0.5f, Color.white);
stats.circlingSpeed = -70f;
stats.requiredKill = false;
return(stats);
}
static private void CreateTowerStats(StatsHolder statsHolder)
{
TextAsset csvText = (TextAsset)AssetDatabase.LoadAssetAtPath(DATABASE_FOLDER + "/CSV/database - tower.csv", typeof(TextAsset));
UnityEngine.Object[] rawSpriteSheet = AssetDatabase.LoadAllAssetsAtPath(TOWER_SPRITE_PATH);
var sprteSheet = rawSpriteSheet.Where(q => q is Sprite).Cast <Sprite>().ToArray();
CSVFile csvFile = new CSVFile(csvText.text);
AssetDatabase.CreateFolder(DATABASE_FOLDER + "/Asset", "Tower");
int csvCount = csvFile.length;
for (int i = csvCount - 1; i >= 0; i--)
{
string id = csvFile.Get <string>(i, "ID");
if (string.IsNullOrEmpty(id))
{
continue;
}
TowerStats c_prefab = ScriptableObjectUtility.CreateAsset <TowerStats>(DATABASE_FOLDER + "/Asset/Tower/", "[TowerStat] " + id);
EditorUtility.SetDirty(c_prefab);
c_prefab.id = id;
c_prefab.label = csvFile.Get <string>(i, "Label");
c_prefab.tag = csvFile.Get <string>(i, "Tag");
c_prefab.hp = csvFile.Get <float>(i, "HP");
c_prefab.level = csvFile.Get <int>(i, "Level");
c_prefab.atk = csvFile.Get <float>(i, "ATK");
c_prefab.spd = csvFile.Get <float>(i, "SPD");
c_prefab.range = csvFile.Get <float>(i, "RANGE");
c_prefab.cost = csvFile.Get <int>(i, "COST");
c_prefab.value = c_prefab.cost;
string upgradePath = csvFile.Get <string>(i, "Update Path");
if (!string.IsNullOrEmpty(upgradePath))
{
string[] upgradePathArray = upgradePath.Split(new string[] { "," }, System.StringSplitOptions.None);
c_prefab = UpdateTowerUpgradePath(c_prefab, statsHolder, upgradePathArray);
}
string rawSkills = csvFile.Get <string>(i, "Skill");
if (!string.IsNullOrEmpty(rawSkills))
{
string[] skillArray = rawSkills.Split(new string[] { "," }, System.StringSplitOptions.None);
c_prefab.skills = GetSkillFromIDs(statsHolder, skillArray);
}
c_prefab.sprite = UtilityMethod.LoadSpriteFromMulti(sprteSheet, csvFile.Get <string>(i, "Sprite ID"));
statsHolder.stpObjectHolder.Add(c_prefab);
}
}
public static StatsHolder ZigZag()
{
StatsHolder stats = new StatsHolder("ZigZag", 0.5f, 2.5f, 1.0f, 100.0f, 1.0f, Color.white);
stats.angularSpeed = 70f;
stats.zigZag = true;
stats.zigZagAngle = 90;
return(stats);
}
static private void CreateMonsterStats(StatsHolder statsHolder)
{
TextAsset csvText = (TextAsset)AssetDatabase.LoadAssetAtPath(DATABASE_FOLDER + "/CSV/database - monster.csv", typeof(TextAsset));
CSVFile csvFile = new CSVFile(csvText.text);
AssetDatabase.CreateFolder(DATABASE_FOLDER + "/Asset", "Monster");
string MonsterAnimatorPath = "Assets/Main/Animation/Monster/{0}/Animator.overrideController";
int csvCount = csvFile.length;
for (int i = csvCount - 1; i >= 0; i--)
{
string id = csvFile.Get <string>(i, "ID");
if (string.IsNullOrEmpty(id))
{
continue;
}
MonsterStats c_prefab = ScriptableObjectUtility.CreateAsset <MonsterStats>(DATABASE_FOLDER + "/Asset/Monster/", "[MonsterStat] " + id);
EditorUtility.SetDirty(c_prefab);
c_prefab.id = id;
c_prefab.label = csvFile.Get <string>(i, "Label");
c_prefab.strategy = (VariableFlag.Strategy)csvFile.Get <int>(i, "Strategy");
c_prefab.value = csvFile.Get <float>(i, "Value");
c_prefab.hp = csvFile.Get <int>(i, "HP");
c_prefab.atk = csvFile.Get <float>(i, "ATK");
c_prefab.spd = csvFile.Get <float>(i, "SPD");
c_prefab.range = csvFile.Get <int>(i, "RANGE");
c_prefab.moveSpeed = csvFile.Get <float>(i, "Move Speed");
c_prefab.avgPrize = csvFile.Get <int>(i, "Prize");
c_prefab.sprite_id = csvFile.Get <string>(i, "Sprite ID");
string rawSkills = csvFile.Get <string>(i, "Skill");
if (!string.IsNullOrEmpty(rawSkills))
{
string[] skillArray = rawSkills.Split(new string[] { "," }, System.StringSplitOptions.None);
c_prefab.skills = GetSkillFromIDs(statsHolder, skillArray);
}
RuntimeAnimatorController animator = AssetDatabase.LoadAssetAtPath(string.Format(MonsterAnimatorPath, c_prefab.sprite_id), typeof(AnimatorOverrideController)) as RuntimeAnimatorController;
if (animator != null)
{
c_prefab.animator = animator;
}
statsHolder.stpObjectHolder.Add(c_prefab);
}
}
public static StatsHolder RangedCirclingEnemy(bool clockwise)
{
StatsHolder stats = new StatsHolder("Shooting Shark", 3.0f, 1.0f, 2.5f, 50.0f, 1.2f, new Color(1.0f, 0.0f, 1.0f, 1.0f));
if (clockwise)
{
stats.circlingSpeed = -30f;
}
else
{
stats.circlingSpeed = 30f;
}
return(stats);
}
public static StatsHolder Rotator(bool clockwise)
{
StatsHolder stats = new StatsHolder("Rotator", 0.7f, 2.5f, 1.0f, 100.0f, 0.7f, Color.blue);
if (clockwise)
{
stats.angularSpeed = -50f;
}
else
{
stats.angularSpeed = 50f;
}
return(stats);
}
public void SetStats(StatsHolder stats)
{
transform.name = stats.Name;
this.circlingSpeed = stats.circlingSpeed;
this.selfDestruct = stats.selfDestruct;
this.invunerable = stats.invunerable;
if (invunerable) //Don't show healthbar for invunerable units (projectiles)
{
Destroy(UnityUtils.RecursiveFind(transform, "HealthBar").gameObject);
}
MoveTo(new RadialPosition(stats.spawnRadius, stats.spawnAngle));
MovementSpeed = stats.MovementSpeed;
this.angularSpeed = stats.angularSpeed;
Damage = stats.Damage;
Range = stats.Range;
Health = stats.Health;
MaxHealth = stats.Health;
Scale = stats.Scale;
Transform sprite = transform.Find("Sprite");
sprite.transform.localScale *= stats.Scale;
if (stats.Scale > 1)
{
Transform canvas = transform.Find("Canvas");
canvas.localPosition = new Vector3(canvas.localPosition.x, canvas.localPosition.y * stats.Scale * 0.8f, canvas.localPosition.z);
}
if (stats.projectile == null)
{
this.projectile = EnemyFactory.Projectile(this.Damage);
}
else
{
this.projectile = stats.projectile;
}
this.attackFrequency = stats.attackDelay;
this.zigZag = stats.zigZag;
if (stats.angularSpeed > 0)
{
this.zigZagAngleLow = stats.spawnAngle;
this.zigZagAngleHigh = stats.spawnAngle + stats.zigZagAngle;
}
else
{
this.zigZagAngleHigh = stats.spawnAngle;
this.zigZagAngleLow = stats.spawnAngle - stats.zigZagAngle;
}
colorModifier.SetDefaultColor(stats.Color);
colorModifier.SetSelectedColor(Parameters.ENEMY_ATTACK_COLOR);
}
static private SkillStats[] GetSkillFromIDs(StatsHolder statsHolder, string[] skillArray)
{
SkillStats[] skillStats = new SkillStats[skillArray.Length];
for (int k = 0; k < skillArray.Length; k++)
{
SkillStats findObject = statsHolder.FindObject <SkillStats>(skillArray[k]);
if (findObject != null)
{
skillStats[k] = findObject;
}
}
return(skillStats);
}
public string GetMessage(StatsHolder stat)
{
List <string> possibleAnswers = new List <string>(regularMessages);
foreach (var j in specialMessages)
{
for (int i = 0; i < (int)StatsHolder.Stat.LAST_STAT; ++i)
{
if (i == (int)j.linkedStat)
{
possibleAnswers.Add(j.GetAnswerInRange(stat.GetStatValue(j.linkedStat)));
}
}
}
return(possibleAnswers[Random.Range(0, possibleAnswers.Count)]);
}
static private TowerStats UpdateTowerUpgradePath(TowerStats c_prefab, StatsHolder statsHolder, string[] upgradePathArray)
{
c_prefab.upgrade_path = new TowerStats[upgradePathArray.Length];
for (int k = 0; k < upgradePathArray.Length; k++)
{
TowerStats findObject = statsHolder.FindObject <TowerStats>(upgradePathArray[k]);
if (findObject != null)
{
c_prefab.upgrade_path[k] = findObject;
findObject.AddValue(c_prefab.cost);
}
}
return(c_prefab);
}
public static StatsHolder Projectile(float damage)
{
StatsHolder stats = new StatsHolder(
"Projectile",
Parameters.PROJECTILE_SPEED,
damage,
Parameters.PROJECTILE_RANGE,
1.0f, //Health of projectile does not matter since they are invunerable.
Parameters.PROJECTILE_SCALE,
Parameters.PROJECTILE_COLOR
);
stats.selfDestruct = true;
stats.invunerable = true;
stats.requiredKill = false;
return(stats);
}
public void SetUp(GameInputManager gameInputManager, GameUnitManager gameUnitManager, LevelDesignManager levelDesign, MapGrid mapGrid, MapBlockManager mapBlockManager,
STPTheme stpTheme, StatsHolder statHolder)
{
_gameInputManager = gameInputManager;
_gameInputManager.OnSelectTileNode += SelectTileListener;
_gameUnitManager = gameUnitManager;
_levelDesignManager = levelDesign;
_mapGrid = mapGrid;
_mapBlockManager = mapBlockManager;
_stpTheme = stpTheme;
_statHolder = statHolder;
if (ConstructionUI != null)
{
ConstructionUI.TowerClickEvent += SelectTowerToBuild;
}
}
// Via deze functie kan je makkelijk de stats per character invullen.
private static StatsHolder GetCharacterTransformStats(string character)
{
StatsHolder stats = new StatsHolder ();
switch(character)
{
// Parrot
case CHARACTER01:
stats.movementSpeed = 0f;
stats.jumpForce = 1f;
stats.fallSpeed = 0f;
stats.stunPower = 1f;
stats.pushPower = 0f;
stats.dashForce = 0f;
break;
// Asian Chick
case CHARACTER02:
stats.movementSpeed = 2f;
stats.jumpForce = 2f;
stats.fallSpeed = 1f;
stats.stunPower = 0.5f;
stats.pushPower = 0.4f;
stats.dashForce = 3f;
break;
case CHARACTER03:
stats.movementSpeed = 0f;
stats.jumpForce = 0f;
stats.fallSpeed = 0f;
stats.stunPower = 0f;
stats.pushPower = 0f;
stats.dashForce = 0f;
break;
case CHARACTER04:
stats.movementSpeed = 2f;
stats.jumpForce = 2f;
stats.fallSpeed = 1f;
stats.stunPower = 0.3f;
stats.pushPower = 0.3f;
stats.dashForce = 2f;
break;
}
return stats;
}
public void StartDialog(GameObject person)
{
dialogWindowAlpha.Show();
dialogAwaliable = true;
currentStats = person.GetComponent <StatsHolder>();
currentDI = person.GetComponent <DialogInitializer>();
OutputDebugInfo();
if (!isFirstDialog)
{
answerText.text = welcomeMessages.GetMessage(currentStats) + '\n';
FillQuestions();
}
else
{
FillFirstDialog();
}
}
public void InstantiateEnemyPrefab(StatsHolder stats)
{
GameObject initEnemy = Instantiate(preInitEnemy);
if (!stats.predefinedPosition)
{
stats.spawnAngle = Random.value * 360;
}
initEnemy.GetComponent <Enemy> ().SetStats(
stats
);
if (stats.requiredKill)
{
waveHandler.NofifyRequiredKillUnitSpawned();
}
initEnemy.name = stats.Name + numberOfEnemies;
numberOfEnemies++;
}
static private void UpdateStatsAsset()
{
StatsHolder statsHolder = (StatsHolder)AssetDatabase.LoadAssetAtPath(DATABASE_FOLDER + "/[Stats]Holder.asset", typeof(StatsHolder));
if (statsHolder != null)
{
FileUtil.DeleteFileOrDirectory(DATABASE_FOLDER + "/Asset");
AssetDatabase.CreateFolder(DATABASE_FOLDER, "Asset");
statsHolder.stpObjectHolder.Clear();
CreateSkillStats(statsHolder);
CreateTowerStats(statsHolder);
CreateMonsterStats(statsHolder);
}
else
{
Debug.LogError("[Stats]Holder.asset has not been created yet!");
}
EditorUtility.SetDirty(statsHolder);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
}
public void InitializeStats()
{
if (statsHolderPrefab == null)
{
return;
}
foreach (Stats item in Enum.GetValues(typeof(Stats)))
{
GameObject tmp = Instantiate(statsHolderPrefab, statsSorter.transform);
statsSorter.items.Add(tmp.transform);
StatsHolder holder = tmp.GetComponent <StatsHolder>();
holder.Initialize(item, owner);
currentStatsList.Add(tmp.GetComponent <StatsHolder>());
}
statsSorter.UpdateTransformPositions();
if (currentStatsList.Count > 4)
{
float sizeDifference = (157.0f * currentStatsList.Count) - 700;
AdjustScrollSize(sizeDifference);
movementLength = sizeDifference;
}
}
private void Start()
{
nextFire = 0f;
stats = GetComponent <StatsHolder>();
}
public CharDBInfo(StatsHolder transformStats)
{
_transformStats = transformStats;
}
public static List <SubWave> GenerateWave(int numberOfEnemies)
{
List <SubWave> wave = new List <SubWave> ();
SubWave subWave;
StatsHolder stats;
switch (numberOfEnemies)
{
case 3:
for (int i = 0; i < 360; i += 45)
{
subWave = new SubWave(2.0f);
stats = EnemyFactory.StandardEnemy();
stats.spawnAngle = i;
stats.predefinedPosition = true;
subWave.AddEnemy(stats);
wave.Add(subWave);
}
break;
case 5:
SubWave bigEnemySubWave = new SubWave(0.0f);
StatsHolder bigEnemy = EnemyFactory.SlowEnemy();
bigEnemy.predefinedPosition = true;
bigEnemy.spawnAngle = 225f;
bigEnemySubWave.AddEnemy(bigEnemy);
wave.Add(bigEnemySubWave);
for (int i = 0; i < 20; i++)
{
StatsHolder minon1 = EnemyFactory.Minion();
minon1.spawnAngle = 65f;
minon1.predefinedPosition = true;
StatsHolder minon2 = EnemyFactory.Minion();
minon2.spawnAngle = 45f;
minon2.predefinedPosition = true;
StatsHolder minon3 = EnemyFactory.Minion();
minon3.spawnAngle = 25f;
minon3.predefinedPosition = true;
SubWave sub1 = new SubWave(3.0f);
sub1.AddEnemy(minon1);
wave.Add(sub1);
SubWave sub2 = new SubWave(3.0f);
sub2.AddEnemy(minon2);
wave.Add(sub2);
SubWave sub3 = new SubWave(3.0f);
sub3.AddEnemy(minon3);
wave.Add(sub3);
}
break;
case 7:
float angle = UnityEngine.Random.value * 360;
for (int i = 0; i < 4; i++)
{
subWave = new SubWave(0.1f);
stats = EnemyFactory.Rotator(true);
stats.spawnAngle = angle + i * 2;
stats.predefinedPosition = true;
subWave.AddEnemy(stats);
wave.Add(subWave);
}
subWave = new SubWave(2.0f);
stats = EnemyFactory.Rotator(true);
stats.spawnAngle = angle + 8;
stats.predefinedPosition = true;
subWave.AddEnemy(stats);
wave.Add(subWave);
for (int i = 0; i < 5; i++)
{
subWave = new SubWave(0.1f);
stats = EnemyFactory.Rotator(false);
stats.spawnAngle = (angle + 180) % 360 + i * 2;
stats.predefinedPosition = true;
subWave.AddEnemy(stats);
wave.Add(subWave);
}
break;
case 8:
subWave = new SubWave(0.0f);
for (int i = 0; i < 360; i += 45)
{
stats = EnemyFactory.Rotator(true);
stats.spawnAngle = i;
stats.predefinedPosition = true;
subWave.AddEnemy(stats);
}
wave.Add(subWave);
break;
case 11:
subWave = new SubWave(2.0f);
stats = EnemyFactory.RangedSpawner();
subWave.AddEnemy(stats);
wave.Add(subWave);
break;
default:
wave = AutoGenerateWave(numberOfEnemies);
break;
}
return(wave);
}
public void RiskStatisticsTest()
{
// ("Testing risk measures...");
IncrementalGaussianStatistics igs = new IncrementalGaussianStatistics();
RiskStatistics s = new RiskStatistics();
double[] averages = { -100.0, -1.0, 0.0, 1.0, 100.0 };
double[] sigmas = { 0.1, 1.0, 100.0 };
int i, j, k, N;
N = (int)Math.Pow(2, 16) - 1;
double dataMin, dataMax;
List <double> data = new InitializedList <double>(N), weights = new InitializedList <double>(N);
for (i = 0; i < averages.Length; i++)
{
for (j = 0; j < sigmas.Length; j++)
{
NormalDistribution normal = new NormalDistribution(averages[i], sigmas[j]);
CumulativeNormalDistribution cumulative = new CumulativeNormalDistribution(averages[i], sigmas[j]);
InverseCumulativeNormal inverseCum = new InverseCumulativeNormal(averages[i], sigmas[j]);
SobolRsg rng = new SobolRsg(1);
dataMin = double.MaxValue;
dataMax = double.MinValue;
for (k = 0; k < N; k++)
{
data[k] = inverseCum.value(rng.nextSequence().value[0]);
dataMin = Math.Min(dataMin, data[k]);
dataMax = Math.Max(dataMax, data[k]);
weights[k] = 1.0;
}
igs.addSequence(data, weights);
s.addSequence(data, weights);
// checks
double calculated, expected;
double tolerance;
if (igs.samples() != N)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong number of samples\n"
+ " calculated: " + igs.samples() + "\n"
+ " expected: " + N);
}
if (s.samples() != N)
{
QAssert.Fail("RiskStatistics: wrong number of samples\n"
+ " calculated: " + s.samples() + "\n"
+ " expected: " + N);
}
// weightSum()
tolerance = 1e-10;
expected = weights.Sum();
calculated = igs.weightSum();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong sum of weights\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.weightSum();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong sum of weights\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// min
tolerance = 1e-12;
expected = dataMin;
calculated = igs.min();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong minimum value\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.min();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: "
+ "wrong minimum value\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// max
expected = dataMax;
calculated = igs.max();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong maximum value\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.max();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: "
+ "wrong maximum value\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// mean
expected = averages[i];
tolerance = (expected == 0.0 ? 1.0e-13 :
Math.Abs(expected) * 1.0e-13);
calculated = igs.mean();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong mean value"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.mean();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong mean value"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// variance
expected = sigmas[j] * sigmas[j];
tolerance = expected * 1.0e-1;
calculated = igs.variance();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong variance"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.variance();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong variance"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// standardDeviation
expected = sigmas[j];
tolerance = expected * 1.0e-1;
calculated = igs.standardDeviation();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong standard deviation"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.standardDeviation();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong standard deviation"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// missing errorEstimate() test
// skewness
expected = 0.0;
tolerance = 1.0e-4;
calculated = igs.skewness();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong skewness"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.skewness();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong skewness"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// kurtosis
expected = 0.0;
tolerance = 1.0e-1;
calculated = igs.kurtosis();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong kurtosis"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.kurtosis();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong kurtosis"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// percentile
expected = averages[i];
tolerance = (expected == 0.0 ? 1.0e-3 :
Math.Abs(expected * 1.0e-3));
calculated = igs.gaussianPercentile(0.5);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong Gaussian percentile"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.gaussianPercentile(0.5);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong Gaussian percentile"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.percentile(0.5);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong percentile"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// potential upside
double upper_tail = averages[i] + 2.0 * sigmas[j],
lower_tail = averages[i] - 2.0 * sigmas[j];
double twoSigma = cumulative.value(upper_tail);
expected = Math.Max(upper_tail, 0.0);
tolerance = (expected == 0.0 ? 1.0e-3 :
Math.Abs(expected * 1.0e-3));
calculated = igs.gaussianPotentialUpside(twoSigma);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong Gaussian potential upside"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.gaussianPotentialUpside(twoSigma);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong Gaussian potential upside"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.potentialUpside(twoSigma);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong potential upside"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// just to check that GaussianStatistics<StatsHolder> does work
StatsHolder h = new StatsHolder(s.mean(), s.standardDeviation());
GenericGaussianStatistics <StatsHolder> test = new GenericGaussianStatistics <StatsHolder>(h);
expected = s.gaussianPotentialUpside(twoSigma);
calculated = test.gaussianPotentialUpside(twoSigma);
if (calculated != expected)
{
QAssert.Fail("GenericGaussianStatistics<StatsHolder> fails"
+ "\n calculated: " + calculated
+ "\n expected: " + expected);
}
// value-at-risk
expected = -Math.Min(lower_tail, 0.0);
tolerance = (expected == 0.0 ? 1.0e-3 :
Math.Abs(expected * 1.0e-3));
calculated = igs.gaussianValueAtRisk(twoSigma);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong Gaussian value-at-risk"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.gaussianValueAtRisk(twoSigma);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong Gaussian value-at-risk"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.valueAtRisk(twoSigma);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong value-at-risk"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
if (averages[i] > 0.0 && sigmas[j] < averages[i])
{
// no data will miss the targets:
// skip the rest of this iteration
igs.reset();
s.reset();
continue;
}
// expected shortfall
expected = -Math.Min(averages[i]
- sigmas[j] * sigmas[j]
* normal.value(lower_tail) / (1.0 - twoSigma),
0.0);
tolerance = (expected == 0.0 ? 1.0e-4
: Math.Abs(expected) * 1.0e-2);
calculated = igs.gaussianExpectedShortfall(twoSigma);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong Gaussian expected shortfall"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.gaussianExpectedShortfall(twoSigma);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong Gaussian expected shortfall"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.expectedShortfall(twoSigma);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong expected shortfall"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// shortfall
expected = 0.5;
tolerance = (expected == 0.0 ? 1.0e-3 :
Math.Abs(expected * 1.0e-3));
calculated = igs.gaussianShortfall(averages[i]);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong Gaussian shortfall"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.gaussianShortfall(averages[i]);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong Gaussian shortfall"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.shortfall(averages[i]);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong shortfall"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// average shortfall
expected = sigmas[j] / Math.Sqrt(2.0 * Const.M_PI) * 2.0;
tolerance = expected * 1.0e-3;
calculated = igs.gaussianAverageShortfall(averages[i]);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong Gaussian average shortfall"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.gaussianAverageShortfall(averages[i]);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong Gaussian average shortfall"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.averageShortfall(averages[i]);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong average shortfall"
+ " for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// regret
expected = sigmas[j] * sigmas[j];
tolerance = expected * 1.0e-1;
calculated = igs.gaussianRegret(averages[i]);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong Gaussian regret(" + averages[i] + ") "
+ "for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.gaussianRegret(averages[i]);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: "
+ "wrong Gaussian regret(" + averages[i] + ") "
+ "for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.regret(averages[i]);
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: "
+ "wrong regret(" + averages[i] + ") "
+ "for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// downsideVariance
expected = s.downsideVariance();
tolerance = (expected == 0.0 ? 1.0e-3 :
Math.Abs(expected * 1.0e-3));
calculated = igs.downsideVariance();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong downside variance"
+ "for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = igs.gaussianDownsideVariance();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong Gaussian downside variance"
+ "for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
// downsideVariance
if (averages[i] == 0.0)
{
expected = sigmas[j] * sigmas[j];
tolerance = expected * 1.0e-3;
calculated = igs.downsideVariance();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong downside variance"
+ "for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = igs.gaussianDownsideVariance();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("IncrementalGaussianStatistics: "
+ "wrong Gaussian downside variance"
+ "for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.downsideVariance();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong downside variance"
+ "for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
calculated = s.gaussianDownsideVariance();
if (Math.Abs(calculated - expected) > tolerance)
{
QAssert.Fail("RiskStatistics: wrong Gaussian downside variance"
+ "for N(" + averages[i] + ", "
+ sigmas[j] + ")\n"
+ " calculated: " + calculated + "\n"
+ " expected: " + expected + "\n"
+ " tolerance: " + tolerance);
}
}
igs.reset();
s.reset();
}
}
}
private void Start()
{
stats = GetComponent <StatsHolder>();
direction.Normalize();
direction = new Vector3(direction.x, direction.y, 0f);
}
