int main(int argc, char * argv[]){
Board * board;
int x, y;
Pos pos;
UCTNode * uct_tree = 0;
UCTNode * ptr;
board_initialize();
uct_initialize();
board = board_new();
while(1) {
board_print(board, stdout);
printf("\nBlack: ");
if(scanf("%d %d", &x, &y) == -1)
break;
board_play(board, to_pos(x, y), BLACK);
board_print(board, stdout);
pos = uct_search(board, WHITE);
board_play(board, pos, WHITE);
}
//for(ptr = uct_tree->child; ptr; ptr = ptr->next)
// printf("%d ", ptr->move);
puts("");
board_destroy();
uct_destroy();
return 0;
}
int UavcanNode::start(uavcan::NodeID node_id, uint32_t bitrate)
{
if (_instance != nullptr) {
PX4_INFO("Already started");
return -1;
}
/*
* CAN driver init
*/
static bool can_initialized = false;
if (!can_initialized) {
// Confgure the HW IO
board_initialize();
const int can_init_res = can.init(bitrate);
if (can_init_res < 0) {
PX4_ERR("CAN driver init failed %i", can_init_res);
return can_init_res;
}
can_initialized = true;
}
/*
* Node init
*/
_instance = newNode();
const int node_init_res = _instance->init(node_id);
if (node_init_res < 0) {
_instance = nullptr;
PX4_ERR("Node init failed %i", node_init_res);
return node_init_res;
}
/* Keep the bit rate for reboots on BenginFirmware updates */
_instance->active_bitrate = bitrate;
return PX4_OK;
}
int os_bringup(void)
{
int taskid;
/* Setup up the initial environment for the idle task. At present, this
* may consist of only the initial PATH variable. The PATH variable is
* (probably) not used by the IDLE task. However, the environment
* containing the PATH variable will be inherited by all of the threads
* created by the IDLE task.
*/
#if !defined(CONFIG_DISABLE_ENVIRON) && defined(CONFIG_PATH_INITIAL)
(void)setenv("PATH", CONFIG_PATH_INITIAL, 1);
#endif
/* Start the page fill worker kernel thread that will resolve page faults.
* This should always be the first thread started because it may have to
* resolve page faults in other threads
*/
#ifdef CONFIG_PAGING
svdbg("Starting paging thread\n");
g_pgworker = KERNEL_THREAD("pgfill", CONFIG_PAGING_DEFPRIO,
CONFIG_PAGING_STACKSIZE,
(main_t)pg_worker, (FAR char * const *)NULL);
DEBUGASSERT(g_pgworker > 0);
#endif
/* Start the worker thread that will serve as the device driver "bottom-
* half" and will perform misc garbage clean-up.
*/
#ifdef CONFIG_SCHED_WORKQUEUE
#ifdef CONFIG_SCHED_HPWORK
#ifdef CONFIG_SCHED_LPWORK
svdbg("Starting high-priority kernel worker thread\n");
#else
svdbg("Starting kernel worker thread\n");
#endif
g_work[HPWORK].pid = KERNEL_THREAD(HPWORKNAME, CONFIG_SCHED_WORKPRIORITY,
CONFIG_SCHED_WORKSTACKSIZE,
(main_t)work_hpthread, (FAR char * const *)NULL);
DEBUGASSERT(g_work[HPWORK].pid > 0);
/* Start a lower priority worker thread for other, non-critical continuation
* tasks
*/
#ifdef CONFIG_SCHED_LPWORK
svdbg("Starting low-priority kernel worker thread\n");
g_work[LPWORK].pid = KERNEL_THREAD(LPWORKNAME, CONFIG_SCHED_LPWORKPRIORITY,
CONFIG_SCHED_LPWORKSTACKSIZE,
(main_t)work_lpthread, (FAR char * const *)NULL);
DEBUGASSERT(g_work[LPWORK].pid > 0);
#endif /* CONFIG_SCHED_LPWORK */
#endif /* CONFIG_SCHED_HPWORK */
#if defined(CONFIG_NUTTX_KERNEL) && defined(CONFIG_SCHED_USRWORK)
/* Start the user-space work queue */
DEBUGASSERT(USERSPACE->work_usrstart != NULL);
taskid = USERSPACE->work_usrstart();
DEBUGASSERT(taskid > 0);
#endif
#endif /* CONFIG_SCHED_WORKQUEUE */
/* Once the operating system has been initialized, the system must be
* started by spawning the user init thread of execution. This is the
* first user-mode thead.
*/
svdbg("Starting init thread\n");
/* Perform any last-minute, board-specific initialization, if so
* configured.
*/
#ifdef CONFIG_BOARD_INITIALIZE
board_initialize();
#endif
/* Start the default application. In a flat build, this is entrypoint
* is given by the definitions, CONFIG_USER_ENTRYPOINT. In the kernel
* build, however, we must get the address of the entrypoint from the
* header at the beginning of the user-space blob.
*/
#ifdef CONFIG_NUTTX_KERNEL
DEBUGASSERT(USERSPACE->us_entrypoint != NULL);
taskid = TASK_CREATE("init", SCHED_PRIORITY_DEFAULT,
CONFIG_USERMAIN_STACKSIZE, USERSPACE->us_entrypoint,
(FAR char * const *)NULL);
#else
taskid = TASK_CREATE("init", SCHED_PRIORITY_DEFAULT,
CONFIG_USERMAIN_STACKSIZE,
(main_t)CONFIG_USER_ENTRYPOINT,
(FAR char * const *)NULL);
#endif
ASSERT(taskid > 0);
/* We an save a few bytes by discarding the IDLE thread's environment. */
#if !defined(CONFIG_DISABLE_ENVIRON) && defined(CONFIG_PATH_INITIAL)
(void)clearenv();
#endif
return OK;
}
int play_game( KalahPlayer top, KalahPlayer bottom, PlayerPosition first_player )
{
Board b_data;
Board *b = &b_data; // as shorthand
board_initialize( b, first_player );
if ( first_player == TOP )
printf( "Player %s begins.\n", top.get_name() );
else
printf( "Player %s begins.\n", bottom.get_name() );
while ( !board_game_over( b ) )
{
int move;
board_print( b );
printf( "\n" );
if ( b->player_to_move == TOP )
{
move = top.make_move( b );
printf( "TOP (%s) chooses move %d.\n", top.get_name(), move );
}
else
{
move = bottom.make_move( b );
printf( "BOTTOM (%s) chooses move %d.\n", bottom.get_name(), move );
}
board_make_move( b, move );
if ( board_game_over( b ) )
{
if ( board_winner( b ) == TOP )
{
printf( "TOP (%s) wins, %d to %d.\n",
top.get_name(),
board_top_score( b ),
board_bottom_score( b ) );
}
else if ( board_winner( b ) == BOTTOM )
{
printf( "BOTTOM (%s) wins, %d to %d.\n",
bottom.get_name(),
board_bottom_score( b ),
board_top_score( b ) );
}
else
{
printf( "TIE!\n" );
}
}
else
{
if ( b->player_to_move == TOP )
printf( "TOP (%s) to move.\n", top.get_name() );
else
printf( "BOTTOM (%s) to move.\n", bottom.get_name() );
}
}
return board_top_score( b );
}
