private void Start()
{
_gameModeDropdown = GameObject.Find("GameModeDropdown").GetComponent <Dropdown>();
List <Dropdown.OptionData> optionDataList = new List <Dropdown.OptionData>();
optionDataList.Add(new Dropdown.OptionData("Select a Game Mode ..."));
for (int position = 0; position < GameModeOptions.options.Length; position++)
{
optionDataList.Add(new Dropdown.OptionData(GameModeOptions.options[position].Label));
}
_gameModeDropdown.AddOptions(optionDataList);
_gameModeDropdown.onValueChanged.AddListener(delegate {
GameModeDropdownChanged(_gameModeDropdown);
});
_difficultyDropdown = GameObject.Find("DifficultyDropdown").GetComponent <Dropdown>();
_difficultyDropdown.onValueChanged.AddListener(delegate {
DifficultyDropdownChanged(_difficultyDropdown);
});
_difficultyDropdown.gameObject.SetActive(false);
_difficultyText = GameObject.Find("DifficultyText").GetComponent <Text>();
_difficultyText.gameObject.SetActive(false);
_startButton = GameObject.Find("StartButton").GetComponent <Button>();
_startButton.onClick.AddListener(delegate {
StartGame(_startButton);
});
_configuration = BoardConfigurationGetter.getConfigurationObject();
_configuration.EnabledGeneralAudio();
_configuration.Difficulty = (DifficultyOptions.Options) 0;
}
private void Start()
{
_configuration = BoardConfigurationGetter.getConfigurationObject();
_configuration.DisabledGeneralAudio();
Player player1 = null;
Player player2 = null;
_restartInfo = GameObject.Find("restartInfo").GetComponent <SpriteRenderer>();
_restartInfo.enabled = false;
_infoPlayerSymbol = GameObject.Find("infoPlayerSymbol").GetComponent <SpriteRenderer>();
if (_configuration.GameModeOption.Value == 1)
{
player1 = new AIPlayer(1, PlayerType.AIPlayer, Cross);
_infoPlayerSymbol.sprite = InfoP1Computer;
}
else
{
player1 = new Player(1, PlayerType.HumanPlayer, Cross);
_infoPlayerSymbol.sprite = InfoP1P2;
}
player2 = new Player(2, PlayerType.HumanPlayer, Circle);
_game = new Game(player1, player2);
_currentPlayerSymbol = GameObject.Find("currentInfo").GetComponent <SpriteRenderer>();
if (_configuration.Starter == 1)
{
SetCurrentPlayer(player1);
}
else
{
SetCurrentPlayer(player2);
}
_finishingGame = false;
InitializeBoardPositions();
}
public void BoardConfigrationTest()
{
IBoardConfiguration boardConfiguration = new BoardConfiguration("5 4");
Assert.AreEqual(boardConfiguration.GetBoard().Max.X, 4);
Assert.AreEqual(boardConfiguration.GetBoard().Max.Y, 3);
}
public void Awake()
{
if (Instance == null)
{
Instance = this;
}
}
public bool IsValid(BoardConfiguration boardConfiguration)
{
if (boardConfiguration.StartPosition == null)
{
return(true);
}
if (boardConfiguration.StartPosition.XCoordinate > (boardConfiguration.Size - 1) ||
boardConfiguration.StartPosition.YCoordinate > (boardConfiguration.Size - 1))
{
return(false);
}
if (boardConfiguration.StartPosition.XCoordinate < 0 ||
boardConfiguration.StartPosition.YCoordinate < 0)
{
return(false);
}
if (boardConfiguration.EndPosition == null &&
boardConfiguration.StartPosition.XCoordinate == 0 &&
boardConfiguration.StartPosition.YCoordinate == 0)
{
return(false);
}
if (boardConfiguration.EndPosition.XCoordinate == boardConfiguration.StartPosition.XCoordinate &&
boardConfiguration.EndPosition.YCoordinate == boardConfiguration.StartPosition.YCoordinate)
{
return(false);
}
return(true);
}
public void SetupSequence()
{
conf = new BoardConfiguration();
conf.AddPin(new DPin()
{
Number = 0
});
conf.AddPin(new DPin()
{
Number = 1
});
conf.AddSequence(new Sequence()
{
Pin = conf.DigitalPins [0],
Chain = new List <SequenceOperation> ()
{
new SequenceOperation()
{
Duration = TimeSpan.FromSeconds(1),
State = DPinState.HIGH
},
new SequenceOperation()
{
Duration = TimeSpan.FromSeconds(1),
State = DPinState.HIGH
}
}
});
}
public Field(BoardConfiguration boardConfiguration, Point localization)
{
this.Localization = localization;
int fieldSize = boardConfiguration.FieldSize;
int boardSize = boardConfiguration.BoardSize;
ClientSize = new Size(fieldSize, fieldSize);
int x = localization.X;
int y = localization.Y;
Location = new Point(
fieldSize + (fieldSize * x) % (fieldSize * boardSize),
fieldSize + (fieldSize * y) % (fieldSize * boardSize)
);
int moveBy = boardConfiguration.ColorForTopLeftCorner == Color.White ? 1 : 0;
BackColor = ((x + y + moveBy) % 2 == 1) ? Color.White : Color.Black;
Name = String.Concat("Field_", y, "_", x);
InitialColor = BackColor;
MouseClick += ClickField;
}
public void GroupTest()
{
var conf = new BoardConfiguration();
for (uint i = 0; i < 10; i++)
{
conf.AddPin(new DPin()
{
Number = i
});
conf.AddSequence(new Sequence()
{
Pin = conf.DigitalPins [(int)i],
GroupName = i.ToString()
});
}
Assert.AreEqual(10, conf.SequenceGroups.Count);
conf.RemoveSequence(5);
Assert.AreEqual(9, conf.SequenceGroups.Count);
conf.Sequences [2].GroupName = conf.Sequences [0].GroupName;
Assert.AreEqual(8, conf.SequenceGroups.Count);
}
/// <summary>
/// Change the adaptation of the last configuration stored.
/// </summary>
public void SetLastMovement(float value)
{
BoardConfiguration bc = configList[configList.Count - 1];
bc.SetLastValue(value);
configList[configList.Count - 1] = bc;
}
public void setBoard(Game game)
{
mBoardConfiguration = game.BoardConfiguration;
mBoardArrangment = game.BoardArrangment;
// calc prefered tiles in width and height
int singleMargin = Application.Context.Resources.GetDimensionPixelSize(Resource.Dimension.card_margin);
float density = Application.Context.Resources.DisplayMetrics.Density;
singleMargin = Math.Max((int)(1 * density), (int)(singleMargin - mBoardConfiguration.Difficulty * 2 * density));
int sumMargin = 0;
for (int row = 0; row < mBoardConfiguration.NumRows; row++)
{
sumMargin += singleMargin * 2;
}
int tilesHeight = (mScreenHeight - sumMargin) / mBoardConfiguration.NumRows;
int tilesWidth = (mScreenWidth - sumMargin) / mBoardConfiguration.NumTilesInRow;
mSize = Math.Min(tilesHeight, tilesWidth);
mTileLayoutParams = new LinearLayout.LayoutParams(mSize, mSize);
mTileLayoutParams.SetMargins(singleMargin, singleMargin, singleMargin, singleMargin);
// build the ui
buildBoard();
}
public static BoardConfiguration getConfigurationObject()
{
Scene configurationZone = SceneManager.GetSceneByName(_configurationZoneName);
GameObject configurationObject = configurationZone.GetRootGameObjects()[0];
BoardConfiguration _boardConfiguration = configurationObject.GetComponent <BoardConfiguration>();
return(_boardConfiguration);
}
private void SetupWorldPosition(BoardConfiguration _boardConfiguration)
{
int indexInBoard = m_tileController.GetModel().PositionInBoard;
int indexColumn = Mathf.CeilToInt(indexInBoard / _boardConfiguration.HorizontalTiles);
int indexRow = Utils.PingPongRepeating(indexInBoard, _boardConfiguration.HorizontalTiles);
Transform tileViewTransform = GetComponent<Transform>();
tileViewTransform.position = new Vector3(indexRow * TILE_MESH_WIDTH, indexColumn* TILE_MESH_HEIGHT, indexColumn * TILE_MESH_WIDTH);
m_tileController.SetWorldPosition(tileViewTransform.position);
}
public TurtleGame(BoardConfiguration boardConfiguration)
{
InitalizeBoard(
boardConfiguration.Size,
boardConfiguration.StartPosition,
boardConfiguration.EndPosition);
AddMines(boardConfiguration.MineCount);
}
public ConfigurationManager(NodeMapper nodeMapper, EdgeMapper edgeMapper, BoardConfiguration boardConfiguration,
SerialConfiguration serialConfiguration, GpioConfiguration gpioConfiguration)
{
_nodeMapper = nodeMapper;
_edgeMapper = edgeMapper;
BoardConfiguration = boardConfiguration;
SerialConfiguration = serialConfiguration;
GpioConfiguration = gpioConfiguration;
}
public MainWindow()
{
InitializeComponent();
InitComboBoxes();
GrayPulsButtons();
_BoardConfiguration = new BoardConfiguration(105, 25, 100);
_RenderSpeed = speed.faster;
_UserGameInfoCenter = new UserInfoCenterM();
_UserSteeringConsole = new UserSteeringConsoleM();
}
public BoardModel(BoardConfiguration _boardConfiguration)
{
m_boardConfiguration = _boardConfiguration;
// Change seed to get other board
//UnityEngine.Random.seed = 54654668;
UnityEngine.Random.seed = 304476056;
CreateBoard();
}
public override bool Equals(object obj)
{
if (obj == null)
{
return(false);
}
BoardConfiguration other = (BoardConfiguration)obj;
return(other.GetBoardConfiguration().Equals(this.boardConfiguration));
}
public void Show()
{
for (int y = 0; y < BoardConfiguration.GetLength(0); y++)
{
for (int x = 0; x < BoardConfiguration.GetLength(1); x++)
{
Console.Write(string.Format($" {BoardConfiguration[y, x]} "));
}
Console.Write(Environment.NewLine);
Console.Write(Environment.NewLine);
}
}
/// <summary>
/// Retrieve the estimation (story points) from the issue, this only works by using the BoardConfiguration
/// </summary>
/// <typeparam name="T">Type for the estimation</typeparam>
/// <param name="boardConfiguration">BoardConfiguration</param>
/// <returns>T or default(T) if there is no value</returns>
public T GetEstimation <T>(BoardConfiguration boardConfiguration)
{
if (boardConfiguration == null)
{
throw new ArgumentNullException(nameof(boardConfiguration));
}
// Get the custom estimation field ID
var estimationCustomField = boardConfiguration.Estimation.Field.FieldId;
// check if there is a custom field for the ID
if (!Fields.CustomFields.ContainsKey(estimationCustomField))
{
return(default);
private void Start()
{
_coin = GetComponent <SpriteRenderer>();
_initScaleX = transform.localScale.x;
_luckyNumber = Random.Range(3f, 6f);
_configuration = BoardConfigurationGetter.getConfigurationObject();
_configuration.Starter = 0;
_audioSource = GetComponent <AudioSource>();
if (_configuration.GameModeOption.Label == "Player X Computer")
{
coinPlayer1 = coinComputer;
coinPlayer2 = coinPlayer;
}
}
/// <summary>
/// Find the board configuration in the historic if exists or return null if doesn't.
/// </summary>
private BoardConfiguration FindBoardConfiguration(string configuration)
{
BoardConfiguration bc = null;
foreach (BoardConfiguration boardConf in historic)
{
if (boardConf.GetBoardConfiguration().Equals(configuration))
{
bc = boardConf;
break;
}
}
return(bc);
}
public void Setup()
{
conf = new BoardConfiguration();
for (int i = 0; i < 5; i++)
{
conf.AddPin(new APin()
{
Number = (uint)i
});
conf.AddPin(new DPin()
{
Number = (uint)i
});
}
}
public void SerializeBoardConfigTest1()
{
var conf = new BoardConfiguration();
conf.AddPin(new APin()
{
Number = 42
});
Formator.Serialize(MemStream, conf);
MemStream.Seek(0, SeekOrigin.Begin);
var confClone = (BoardConfiguration)Formator.Deserialize(MemStream);
Assert.AreEqual(conf.Pins[0], confClone.Pins[0]);
}
private void arrangeBoard()
{
BoardConfiguration boardConfiguration = mPlayingGame.BoardConfiguration;
BoardArrangment boardArrangment = new BoardArrangment();
// build pairs
// result {0,1,2,...n} // n-number of tiles
List <int> ids = new List <int>();
for (int i = 0; i < boardConfiguration.NumTiles; i++)
{
ids.Add(i);
}
// shuffle
// result {4,10,2,39,...}
var rnd = new Random();
ids = ids.OrderBy(item => rnd.Next()).ToList();
// place the board
List <string> tileImageUrls = mPlayingGame.Theme.TileImageUrls;
tileImageUrls = tileImageUrls.OrderBy(item => rnd.Next()).ToList();
boardArrangment.pairs = new Dictionary <int, int>();
boardArrangment.tileUrls = new Dictionary <int, string>();
int j = 0;
for (int i = 0; i < ids.Count; i++)
{
if (i + 1 < ids.Count)
{
// {4,10}, {2,39}, ...
boardArrangment.pairs.Add(ids[i], ids[i + 1]);
// {10,4}, {39,2}, ...
boardArrangment.pairs.Add(ids[i + 1], ids[i]);
// {4,
boardArrangment.tileUrls.Add(ids[i], tileImageUrls[j]);
boardArrangment.tileUrls.Add(ids[i + 1], tileImageUrls[j]);
i++;
j++;
}
}
mPlayingGame.BoardArrangment = boardArrangment;
}
public bool IsValid(BoardConfiguration boardConfiguration)
{
var avaibableSpaces = boardConfiguration.Size * boardConfiguration.Size;
var mineRatio = avaibableSpaces / boardConfiguration.MineCount;
if (mineRatio > MaxMineThreshold)
{
return(false);
}
if (mineRatio < MinMineThreshold)
{
return(false);
}
return(true);
}
public void SerializeBoardConfigTest2()
{
var conf = new BoardConfiguration();
conf.Board.AnalogReferenceVoltageType = "INTERNAL";
conf.Board.AnalogReferenceVoltage = 4.24;
var pin = new APin()
{
Number = 42
};
var MeCom = new MeasurementCombination();
MeCom.AddPin(pin);
conf.AddPin(pin);
conf.AddMeasurementCombination(MeCom);
Formator.Serialize(MemStream, conf);
MemStream.Seek(0, SeekOrigin.Begin);
var confClone = (BoardConfiguration)Formator.Deserialize(MemStream);
Assert.AreEqual(conf.Pins[0], confClone.Pins[0]);
Assert.AreEqual(conf.MeasurementCombinations[0], confClone.MeasurementCombinations[0]);
Assert.AreEqual(4.24, conf.Board.AnalogReferenceVoltage, 0.000000001);
Assert.AreEqual(4.24, confClone.Board.AnalogReferenceVoltage, 0.000000001);
Assert.AreEqual("INTERNAL", conf.Board.AnalogReferenceVoltageType);
Assert.AreEqual("INTERNAL", confClone.Board.AnalogReferenceVoltageType);
Assert.AreSame(conf.Pins[0], conf.MeasurementCombinations[0].Pins[0]);
Assert.AreSame(confClone.Pins[0], confClone.MeasurementCombinations[0].Pins[0]);
conf.Pins[0].Name = "Dulli";
Assert.AreEqual(conf.Pins[0].Name, conf.MeasurementCombinations[0].Pins[0].Name);
Assert.AreEqual(19, confClone.AvailableDigitalPins.Length);
Assert.AreEqual(6, confClone.AvailableAnalogPins.Length);
conf.ClearPins();
Assert.AreEqual(0, conf.Pins.Count);
Assert.AreEqual(0, conf.MeasurementCombinations.Count);
}
/// <summary>
/// Return the bigger mean in a tree of a Given depth.
/// This function make a recursive call.
/// </summary>
private float MeanAdaptation(string configuration, float sum, int depth)
{
BoardConfiguration bc = FindBoardConfiguration(configuration);
// Stop when the configuration doesn't exists or reached the max depth.
if (bc == null)
{
return(sum / depth);
}
if (depth > MAX_DEPTH)
{
return(sum / (depth - 1));
}
// Select the best adaptation of the possible movements ever tried.
float betterAdaptation = addap;
foreach (MovementConfiguration mc in bc.GetMovementsConfigurations())
{
// if this configuration do not end up with another, return the mean.
float confAdaptation = mc.GetAdaptation();
if (mc.GetResults().Count == 0 &&
betterAdaptation < (sum + confAdaptation) / depth)
{
betterAdaptation = (sum + confAdaptation) / depth;
}
Debug.Log("adaptation: " + confAdaptation);
// Get the best mean adaptation of each result.
foreach (string result in mc.GetResults())
{
float adaptation = MeanAdaptation(result, sum + confAdaptation, depth + 1);
if (adaptation > betterAdaptation)
{
betterAdaptation = adaptation;
}
}
}
return(betterAdaptation);
}
public void SetupMeasurementCombination()
{
conf = new BoardConfiguration();
conf.AddPin(new APin()
{
Number = 0
});
conf.AddPin(new APin()
{
Number = 1
});
conf.AddMeasurementCombination(new MeasurementCombination()
{
Pins = new List <APin> ()
{
conf.AnalogPins [0], conf.AnalogPins [1]
},
});
}
public void RandomMove()
{
string configuration = TranslateBoard();
Movement choseMove;
ArrayList botPieces = base.board.GetEnemyPieces();
ArrayList possibleMoves = ga.GenerateMutations(this, botPieces);
int randomIndex = UnityEngine.Random.Range(0, possibleMoves.Count);
choseMove = (Movement)possibleMoves[randomIndex];
BoardConfiguration bConfig = new BoardConfiguration(configuration);
bConfig.AddMovement(choseMove, ga.AdaptationScore(choseMove));
configList.Add(bConfig);
// Make the movement.
Debug.Log("Chosed Movement: " + choseMove.ToString());
lastMovement = choseMove;
base.board.MovePiece(choseMove);
}
public void DPinCloneTest2()
{
string name = "TestPin";
conf = new BoardConfiguration();
conf.AddPin(new DPin()
{
Number = 5,
Name = name
});
conf.ClonePin(conf.DigitalPins [0]);
Assert.AreEqual(2, conf.DigitalPins.Count);
Assert.AreEqual(name, conf.DigitalPins [0].Name);
Assert.AreEqual(name, conf.DigitalPins [1].Name);
conf.DigitalPins [0].Name = string.Empty;
Assert.AreEqual(name, conf.DigitalPins [1].Name);
}
public void StartIsNotOnBoard()
{
IBoardConfiguration boardConfiguration = new BoardConfiguration("5 4");
IExitConfiguration exitConfiguration = new ExitConfiguration("4 2");
IMinesConfiguration minesConfiguration = new MinesConfiguration("1,1 1,3 3,3");
IMoveConfiguration moveConfiguration = new MoveConfiguration(new List <string>()
{
"M R L", "L M R", "R M L"
});
IStartConfiguration startConfiguration = new StartConfiguration("6 9 N");
IBoard board = boardConfiguration.GetBoard();
List <ICoordinate> mines = minesConfiguration.GetMines();
ICoordinate exit = exitConfiguration.GetExitPoint();
IPosition start = startConfiguration.GetStartPoint();
List <List <MoveType> > moves = moveConfiguration.GetMoves();
ITurtle turtle = new Turtle(start);
IGameValidator gameValidator = new GameValidator(board, mines, exit, start, moves, turtle);
gameValidator.Validate();
}
public void CSVMappingTest()
{
var con = new BoardConfiguration();
con.AddPin(new APin()
{
Number = 1, Name = "Pin1"
});
con.AddPin(new APin()
{
Number = 2, Name = "Pin2"
});
con.AddPin(new APin()
{
Number = 3, Name = "Pin3"
});
var res = con.CreateMapping();
Assert.AreEqual(3, res.Keys.Count);
Assert.AreEqual(0, res [con.Pins [0].DisplayName]);
Assert.AreEqual(1, res [con.Pins [1].DisplayName]);
Assert.AreEqual(2, res [con.Pins [2].DisplayName]);
con.AddMeasurementCombination(new MeasurementCombination()
{
Pins = new System.Collections.Generic.List <APin> ()
{
con.Pins [0] as APin, con.Pins [1] as APin
},
Name = "MeCom"
});
res = con.CreateMapping();
Assert.AreEqual(4, res.Keys.Count);
Assert.AreEqual(3, res [con.MeasurementCombinations [0].DisplayName]);
}
