private Program(int playerNumber)
        {
            engine = new Engine.BaseTypes.Engine(playerNumber);
            this.playerNumber = playerNumber;

            emergencyCells = new List<int>(baseEmergensyCells);
            for (int i = 0; i < 256; i++)
                if (!workCells.Contains(i) && !emergencyCells.Contains(i) && i >= 10)
                    freeCells.Add(i);
        }
        public void TestFunctionHelp()
        {
            var eng = new Engine.BaseTypes.Engine(0);

            var cell1 = eng.getPlayerCells()[1];
            var cell2 = eng.getPlayerCells()[2];

            cell1.setVitality(100);
            cell2.setVitality(100);

            var part1 = new FunctionHelp().exec(new Digit(1));
            var part2 = part1.exec(new Digit(2));
            var result = part2.exec(new Digit(20));

            Assert.AreEqual(80, cell1.getVitality());
            Assert.AreEqual(122, cell2.getVitality());
        }
        public void TestFunctionS()
        {
            var eng = new Engine.BaseTypes.Engine(0);

            var cell = eng.getPlayerCells()[2];
            cell.setValue(new FunctionDbl());

            var zero = new FunctionZero();
            var one = new FunctionSucc().exec(zero);
            var two = new FunctionDbl().exec(one);

            var g = new FunctionDbl();

            var f = new FunctionGet();

            var part1 = new FunctionS().exec(f);
            var part2 = part1.exec(g);
            var res = part2.exec(two);

            Assert.AreEqual(true, res.isDigit());
            Assert.AreEqual(8, (res as Digit).digit);
        }
 private Program(int playerNumber)
 {
     engine = new Engine.BaseTypes.Engine(playerNumber);
     this.playerNumber = playerNumber;
 }
        public void TestRunRound()
        {
            var eng = new Engine.BaseTypes.Engine(0);
            Assert.AreEqual(true, eng.isFirstActive());
            eng.runRound(false, 0, new FunctionPut());
            Assert.AreEqual(false, eng.isFirstActive());
            eng.runRound(false, 0, new FunctionPut());// second
            eng.runRound(true, 0, new FunctionZero());
            eng.runRound(false, 0, new FunctionPut());// second
            eng.runRound(false, 0, new FunctionSucc());
            eng.runRound(false, 0, new FunctionPut());// second
            eng.runRound(false, 0, new FunctionDbl());
            eng.runRound(false, 0, new FunctionPut());// second

            var cell = eng.getPlayerCells()[0];
            Assert.AreEqual(2, (cell.getValue() as Digit).digit);
        }
        public void TestFunctionsReviveCopy()
        {
            var eng = new Engine.BaseTypes.Engine(0);

            var cell1 = eng.getPlayerCells()[1];
            cell1.setVitality(0);

            var cell2 = eng.getOpponentCells()[20];
            cell2.setValue(new Digit(5));

            var revive = new FunctionRevive();
            revive.exec(new Digit(1));

            Assert.AreEqual(1, cell1.getVitality());

            var copy = new FunctionCopy();
            var rescopy = copy.exec(new Digit(20));

            Assert.AreEqual(true, rescopy.isDigit());
            Assert.AreEqual(5, (rescopy as Digit).digit);
        }
        public void TestFunctionsIncAndDec()
        {
            var eng = new Engine.BaseTypes.Engine(0);

            var inc = new FunctionInc();
            var dec = new FunctionDec();

            inc.exec(new Digit(0));
            dec.exec(new Digit(0));

            var cell1 = eng.getPlayerCells()[0];
            var cell2 = eng.getOpponentCells()[255];

            Assert.AreEqual(Cell.START_VITALITY, cell1.getVitality());
            Assert.AreEqual(Cell.START_VITALITY - 1, cell2.getVitality());
        }
        public void TestFunctionsGetAndPut()
        {
            var eng = new Engine.BaseTypes.Engine(0);

            var get = new FunctionGet();
            var resGet = get.exec(new Digit(0));
            Assert.IsTrue(resGet is FunctionI);

            var put = new FunctionPut();
            var resPut = put.exec(new Digit(10));
            Assert.IsTrue(resGet is FunctionI);
        }