private void HandleBranchMovement() //branches are moving while Oscar always remains in the same position on the y-axis
{
for (int i = 0; i < branchList.Count; i++)
{
Branch branch = branchList[i];
//check that branches have not moved below Oscar before moving
bool branchIsaboveOscar = branch.GetYPosition() > Oscar.GetInstance().GetOscarYPosition();
branch.Move();
//check if branch that was previously above Oscar is now below him
if (branchIsaboveOscar && branch.GetYPosition() < Oscar.GetInstance().GetOscarYPosition())
{
branchesPassed++;
//SoundManager.PlaySound(SoundManager.Sound.Score);
SoundManager.PlaySound(SoundManager.Sound.Bark);
}
if (branch.GetYPosition() < BRANCH_DESTROY_Y_POSITION)
{
//Destroy branch
branch.DestroySelf();
branchList.Remove(branch);
i--;
}
}
}
private void Start()
{
highscoreText.text = "HIGHSCORE: " + Score.GetHighScore().ToString();
Hide();
Oscar.GetInstance().OnStartPlaying += ScoreWindow_OnStartPlaying;
Oscar.GetInstance().OnHit += ScoreWindow_OnHit;
}
private void HandleBranchSpawning()
{
branchSpawnTimer -= Time.deltaTime;
if (branchSpawnTimer < 0)
{
//spawn another branch
branchSpawnTimer += branchSpawnTimerMax; //reset timer
float minWidth = Oscar.GetInstance().GetOscarWidth(); //set minimum branch width
float maxWidth = GetCameraHalfWidth() * 2f -
Oscar.GetInstance().GetOscarWidth(); //set maximum branch width
//set up single branch
float width = Random.Range(minWidth, maxWidth);
//set up branch pair
float pairRightWidth = Random.Range(minWidth, maxWidth);
float pairLeftWidth = maxWidth - pairRightWidth;
if (TryGeneratBranchPair() == true)
{
CreateBranchPair(pairRightWidth, pairLeftWidth, BRANCH_SPAWN_Y_POSITION);
branchesSpawned++;
branchesSpawned++;
}
else
{
CreateBranch(width, BRANCH_SPAWN_Y_POSITION, GetRandomBranchType());
branchesSpawned++;
}
SetDifficulty(GetDifficulty());
}
}
public override void OnTap()
{
Oscar oscar = Oscar.Instance;
oscar.SetIdle(false);
Camera.main.transform.parent = oscar.transform;
}
public void TestThreshold()
{
var pix = new Pix(@"Tests\Barcode_Test02_valid_block_2.bmp");
var oscar = new Oscar(pix);
Assert.AreEqual((int)((255 * pix.Width * pix.BytesPerPixel) * Barcode.LUMINACE_FACTOR), (int)oscar.Threshold);
}
private void Awake()
{
instance = this;
OscarRigidbody2D = GetComponent <Rigidbody2D>();
OscarSprite = GetComponent <SpriteRenderer>();
//Static when state is 'waiting to start'
OscarRigidbody2D.bodyType = RigidbodyType2D.Static;
}
private void SetDifficulty(Difficulty difficulty)
{
switch (difficulty)
{
case Difficulty.Easy:
branchSpawnTimerMax = 1.6f;
break;
case Difficulty.Medium:
branchSpawnTimerMax = 1.4f;
cloudMoveSpeed = MOVE_SPEED * 0.3f;
cloudSpawnTimerMax = 2.6f;
break;
case Difficulty.Hard:
branchSpawnTimerMax = 1.2f;
cloudMoveSpeed = MOVE_SPEED * 0.4f;
cloudSpawnTimerMax = 2.2f;
break;
case Difficulty.Brutal:
branchSpawnTimerMax = 1.0f;
cloudMoveSpeed = MOVE_SPEED * 0.5f;
cloudSpawnTimerMax = 1.9f;
break;
case Difficulty.Nightmare1:
branchSpawnTimerMax = 0.8f;
cloudMoveSpeed = MOVE_SPEED * 0.6f;
cloudSpawnTimerMax = 1.6f;
//make Oscar faster as branch spawn time gets smaller
Oscar.GetInstance().SetOscarMoveSpeed(40f);
break;
case Difficulty.Nightmare2:
branchSpawnTimerMax = 0.6f;
cloudMoveSpeed = MOVE_SPEED * 0.8f;
cloudSpawnTimerMax = 1.3f;
break;
case Difficulty.Nightmare3:
Oscar.GetInstance().SetOscarMoveSpeed(100f);
branchSpawnTimerMax = 0.5f;
cloudMoveSpeed = MOVE_SPEED * 0.9f;
cloudSpawnTimerMax = 1.0f;
break;
case Difficulty.Impossible:
Oscar.GetInstance().SetOscarMoveSpeed(200f);
branchSpawnTimerMax = 0.45f;
cloudMoveSpeed = MOVE_SPEED;
cloudSpawnTimerMax = 0.8f;
break;
}
}
public void TestPulsesToNibbles_PNG()
{
var pix = new Pix(@"Tests\Pocorgtfo12-53_24bit.png");
Assert.AreEqual(4352, pix.Width);
Assert.AreEqual(5648, pix.Height);
var oscar = new Oscar(pix);
Assert.AreEqual((int)((255 * (pix.Stride - pix.Padding)) * Barcode.LUMINACE_FACTOR), (int)oscar.Threshold);
var blocks = oscar.GetBlocks();
Assert.AreEqual(31, blocks.Count());
Assert.AreEqual(127, blocks[0].Height);
Assert.AreEqual(63, blocks[0].MidlineIndex);
var pulses0 = blocks[0].ComputePulses();
var pulses1 = blocks[1].ComputePulses();
Assert.AreEqual(433, pulses0.Length);
Assert.AreEqual(false, blocks[0].IsReversedPulse);
Assert.AreEqual(true, blocks[1].IsReversedPulse);
var symbols0 = oscar.PulsesToSymbols(pulses0);
var symbolstring = symbols0.Select(x => x.ToString()).Aggregate((current, next) => current + next);
var expected = "1010101010011001001100101010010011001101101010110011011"; // too lazy to count more from source png file....
Assert.IsTrue(symbolstring.StartsWith(expected));
var nibbles0 = oscar.SymbolsToNibbles(symbols0);
var symbols1 = oscar.PulsesToSymbols(pulses1);
var nibbles1 = oscar.SymbolsToNibbles(symbols1);
// seems to be around 700/701 symbols always resolving to 100 nibbles each (last symbol is EOL)
Assert.AreEqual(701, symbols0.Length);
Assert.AreEqual(701, symbols1.Length);
Assert.AreEqual(100, nibbles0.Length);
Assert.AreEqual(100, nibbles1.Length);
var pulses2 = blocks[2].ComputePulses();
var symbols2 = oscar.PulsesToSymbols(pulses2);
var nibbles2 = oscar.SymbolsToNibbles(symbols2);
Assert.AreEqual(700, symbols2.Length);
Assert.AreEqual(100, nibbles2.Length);
}
public void TestSymbolFromStringToNibbles()
{
var symbolstring = "101010101001100100110010101001010011111111";
var oscar = new Oscar(symbolstring);
var symbols = symbolstring.Select(x => int.Parse(x.ToString())).ToArray();
var nibbles = oscar.SymbolsToNibbles(symbols);
Assert.AreEqual(0xD, nibbles[0]);
Assert.AreEqual(0x0, nibbles[1]);
Assert.AreEqual(0x0, nibbles[2]);
Assert.AreEqual(0x1, nibbles[3]);
Assert.AreEqual(0xA, nibbles[4]);
Assert.AreEqual(0x10, nibbles[5]);
}
public void TestPulsesToNibbles()
{
var pix = new Pix(@"Tests\Databar_Test01_artificial.bmp");
Assert.AreEqual(122, pix.Width);
Assert.AreEqual(77, pix.Height);
var oscar = new Oscar(pix);
Assert.AreEqual((int)((255 * pix.Width * pix.BytesPerPixel) * Barcode.LUMINACE_FACTOR), (int)oscar.Threshold);
var blocks = oscar.GetBlocks();
Assert.AreEqual(1, blocks.Count());
Assert.AreEqual(77, blocks[0].Height);
Assert.AreEqual(pix.Depth / 8, blocks[0].Bits);
Assert.AreEqual(pix.Width * pix.BytesPerPixel, blocks[0].Width);
Assert.AreEqual(38, blocks[0].MidlineIndex);
var pulses = blocks[0].ComputePulses();
Assert.AreEqual(27, pulses.Length);
Assert.AreEqual(false, blocks[0].IsReversedPulse);
var symbols = oscar.PulsesToSymbols(pulses);
var symbolstring = symbols.Select(x => x.ToString()).Aggregate((current, next) => current + next);
Assert.AreEqual("101010101001100100110010101001010011111111", symbolstring);
//1010101 0xD
//0100110 0x0
//0100110 0x0
//0101010 0x1
//0101001 0xA
//1111111 EOL
var nibbles = oscar.SymbolsToNibbles(symbols);
Assert.AreEqual(0xD, nibbles[0]);
Assert.AreEqual(0x0, nibbles[1]);
Assert.AreEqual(0x0, nibbles[2]);
Assert.AreEqual(0x1, nibbles[3]);
Assert.AreEqual(0xA, nibbles[4]);
}
public void TestGetAVGLine()
{
var pix = new Pix(@"Tests\Barcode_Test03_avglines.bmp");
Assert.AreEqual(91, pix.Width);
Assert.AreEqual(46, pix.Height);
var oscar = new Oscar(pix);
Assert.AreEqual((int)((255 * (pix.Stride - pix.Padding)) * Barcode.LUMINACE_FACTOR), (int)oscar.Threshold);
var blocks = oscar.GetBlocks();
Assert.AreEqual(1, blocks.Count());
Assert.AreEqual(44, blocks[0].Height);
Assert.AreEqual(pix.Depth / 8, blocks[0].Bits);
Assert.AreEqual(pix.Width * pix.BytesPerPixel, blocks[0].Width);
Assert.AreEqual(22, blocks[0].MidlineIndex);
var lines = blocks[0].GetAVGLine();
Assert.AreEqual(91, lines.Length);
var white = (blocks[0].EndIndex - blocks[0].StartIndex) * 255;
var black = 0;
Assert.AreEqual(white, lines[0].AVG);
Assert.AreEqual(white, lines[5].AVG);
Assert.AreEqual(black, lines[6].AVG);
Assert.AreEqual(white, lines[21].AVG);
Assert.AreEqual(black, lines[20].AVG);
Assert.AreEqual(white, lines[44].AVG);
Assert.AreEqual(black, lines[45].AVG);
Assert.AreEqual(white, lines[52].AVG);
Assert.AreEqual(black, lines[51].AVG);
Assert.AreEqual(white, lines[59].AVG);
Assert.AreEqual(black, lines[60].AVG);
Assert.AreEqual(white, lines[67].AVG);
Assert.AreEqual(black, lines[66].AVG);
Assert.AreEqual(white, lines[82].AVG);
Assert.AreEqual(black, lines[83].AVG);
Assert.AreEqual(black, lines[90].AVG);
}
public void TestGetBlocks()
{
var pix = new Pix(@"Tests\Barcode_Test02_valid_block_2.bmp");
var oscar = new Oscar(pix);
var result = oscar.GetBlocks();
Assert.AreEqual(2, result.Count());
Assert.AreEqual(108, result[0].Height);
Assert.AreEqual(pix.Depth / 8, result[0].Bits);
Assert.AreEqual(pix.Width * pix.BytesPerPixel, result[0].Width);
Assert.AreEqual(54, result[0].MidlineIndex);
Assert.AreEqual(96, result[1].Height);
Assert.AreEqual(pix.Depth / 8, result[1].Bits);
Assert.AreEqual(pix.Width * pix.BytesPerPixel, result[1].Width);
Assert.AreEqual(48, result[1].MidlineIndex);
}
public void TestComputePulses()
{
var pix = new Pix(@"Tests\Barcode_Test03_avglines.bmp");
Assert.AreEqual(91, pix.Width);
Assert.AreEqual(46, pix.Height);
var oscar = new Oscar(pix);
Assert.AreEqual((int)((255 * pix.Width * pix.BytesPerPixel) * Barcode.LUMINACE_FACTOR), (int)oscar.Threshold);
var blocks = oscar.GetBlocks();
Assert.AreEqual(1, blocks.Count());
Assert.AreEqual(44, blocks[0].Height);
Assert.AreEqual(pix.Depth / 8, blocks[0].Bits);
Assert.AreEqual(pix.Width * pix.BytesPerPixel, blocks[0].Width);
Assert.AreEqual(22, blocks[0].MidlineIndex);
Assert.AreEqual(false, blocks[0].IsReversedPulse);
var pulses = blocks[0].ComputePulses();
Assert.AreEqual(7, pulses.Length);
// will reverse the array because last black pulse is longer than first one
Assert.AreEqual(true, blocks[0].IsReversedPulse);
Assert.AreEqual(15, pulses[6].Length);
Assert.AreEqual(24, pulses[5].Length);
Assert.AreEqual(7, pulses[4].Length);
Assert.AreEqual(8, pulses[3].Length);
Assert.AreEqual(7, pulses[2].Length);
Assert.AreEqual(16, pulses[1].Length);
Assert.AreEqual(8, pulses[0].Length);
}
public void BotMakeBetTest()
{
Bot justPlayer = new Bot(1);
OneThreeTwoSix testBot = new OneThreeTwoSix(1);
Martingale marty = new Martingale(1);
Oscar oscar = new Oscar(1);
Bot[] botSet = new Bot[] { testBot, marty, oscar };
for (int j = 0; j < 4; j++)
{
justPlayer.ChangeBank(-justPlayer.GiveResponce());
justPlayer.ChangeBank(10000);
justPlayer.MakeBet(j);
if (justPlayer.GetBet(j) != 100 || justPlayer.GiveResponce() != 10000 - 100)
{
Assert.Fail();
}
for (int k = 0; k < 5; k++)
{
marty.ChangeBank(10000);
marty.LastBank = marty.GiveResponce() + 1;
marty.LoseStreak = k;
marty.MakeBet(j);
testBot.ChangeBank(10000);
testBot.Step = k;
testBot.LastBank = 0;
testBot.MakeBet(j);
oscar.Wins = k;
oscar.ChangeBank(10000);
oscar.LastBank = 10001;
oscar.MakeBet(j);
switch (k)
{
case 0:
{
if (marty.GiveResponce() != 9800 || marty.GetBet(j) != 200 ||
testBot.GetBet(j) != 50 || testBot.GiveResponce() != 9950 ||
oscar.GetBet(j) != 100 || oscar.GiveResponce() != 9900)
{
Assert.Fail();
}
break;
}
case 1:
{
if (marty.GiveResponce() != 9600 || marty.GetBet(j) != 400 ||
testBot.GiveResponce() != 9850 || testBot.GetBet(j) != 150 ||
oscar.GetBet(j) != 103 || oscar.GiveResponce() != 9897)
{
Assert.Fail();
}
break;
}
case 2:
{
if (marty.GiveResponce() != 9200 || marty.GetBet(j) != 800 ||
testBot.GetBet(j) != 100 || testBot.GiveResponce() != 9900 ||
oscar.GetBet(j) != 106 || oscar.GiveResponce() != 9894)
{
Assert.Fail();
}
break;
}
case 3:
{
if (marty.GiveResponce() != 8400 || marty.GetBet(j) != 1600 ||
testBot.GiveResponce() != 9700 | testBot.GetBet(j) != 300 ||
oscar.GetBet(j) != 109 || oscar.GiveResponce() != 9891)
{
Assert.Fail();
}
break;
}
case 4:
{
if (marty.GiveResponce() != 6800 || marty.GetBet(j) != 3200 ||
testBot.Step != 0 || testBot.GetBet(j) != 50 || testBot.GiveResponce() != 9950 ||
oscar.GetBet(j) != 112 || oscar.GiveResponce() != 9888)
{
Assert.Fail();
}
break;
}
default:
{
if (marty.GiveResponce() != 3600 | marty.GetBet(j) != 6400)
{
Assert.Fail();
}
break;
}
}
marty.ChangeBank(-marty.GiveResponce());
testBot.ChangeBank(-testBot.GiveResponce());
oscar.ChangeBank(-oscar.GiveResponce());
}
}
Assert.Pass();
}
private void Start()
{
Oscar.GetInstance().OnHit += Oscar_OnHit;
Oscar.GetInstance().OnStartPlaying += Oscar_OnStartPlaying;
}
public static void Start()
{
Oscar.GetInstance().OnHit += Oscar_OnHit;
}
private void Start()
{
Oscar.GetInstance().OnHit += Oscar_OnHit;
Hide();
}
private void Start()
{
Oscar.GetInstance().OnStartPlaying += WaitingToStartWindow_OnStartPlaying;
}
public void TestParseNibbles_PNG()
{
var testset = new Pix(@"Tests\Pocorgtfo12-53_24bit.png");
var resultset = System.IO.File.ReadAllLines(@"Tests\OscarCompareResult_Pocorgtfo12-53_24bit.txt").
Where(x => !x.StartsWith(@"//"));
Assert.AreEqual(4352, testset.Width);
Assert.AreEqual(5648, testset.Height);
var oscar = new Oscar(testset);
var blocks = oscar.GetBlocks();
var pulses = new List <Barcode.Pulse[]>(blocks.Count);
foreach (var b in blocks)
{
pulses.Add(b.ComputePulses());
}
var symbols = new List <int[]>(pulses.Count);
foreach (var p in pulses)
{
symbols.Add(oscar.PulsesToSymbols(p));
}
var nibbles = new List <int[]>(symbols.Count);
foreach (var s in symbols)
{
nibbles.Add(oscar.SymbolsToNibbles(s));
}
var results = new List <int[]>(symbols.Count);
foreach (var n in nibbles)
{
if (n == null)
{
continue;
}
results.Add(oscar.ParseNibbles(n));
}
Assert.IsNull(results[0]);// control array so result should be null
List <string> hexstrings = new List <string>(results.Count());
foreach (var r in results)
{
if (r == null)
{
continue;
}
hexstrings.Add(r.Select(x => x.ToString("x2")).Aggregate((a, b) => a + b));
}
int pos = -1;
foreach (var expected in resultset)
{
pos++;
if (pos == 1 || pos == 11 || pos == 13)
{
// will fail
continue;
}
Assert.AreEqual(expected, hexstrings[pos]);
}
Assert.Inconclusive("data lines 1, 11 and 13 are not matching!");
}
