void Board::takeStep(){
checkTurn();
vec step = inputVec();
if(step == vec(-1, -1)){
fprintf(stderr, "no input vector!\n");
step = inputVec();
}
while(!canFlip(step.x, step.y, turnToPieceType(turn))){
fprintf(stderr, "invalid input (%d, %d)!\n", step.x, step.y);
step = inputVec();
}
setPieces(step.x, step.y);
if(checkEnd()){
if(countColor(black) > countColor(white)){
printf("black: %d\n", countColor(black));
printf("white: %d\n", countColor(white));
printf("black wins!\n");
}
else if(countColor(black) < countColor(white)){
printf("black: %d\n", countColor(black));
printf("white: %d\n", countColor(white));
printf("white wins!\n");
}
else{
printf("black: %d\n", countColor(black));
printf("white: %d\n", countColor(white));
printf("ties!\n");
}
printBoard();
exit(0);
}
else{
printBoard();
}
}
int main(int argc, char* argv[])
{
std::size_t test_case = 0;
std::size_t count_inv;
switch (test_case)
{
case 0:
{
std::vector<int> inputVec;
inputVec.reserve(100000);
textReader("D:/cpp_practise/test_cases/IntegerArray.txt",inputVec);
count_inv = sort_count_inversion(inputVec,0,inputVec.size()-1);
int gh = 0;
}
break;
case 1:
{
std::vector<int> inputVec;
inputVec.reserve(100000);
textReader("D:/cpp_practise/test_cases/IntegerArray.txt",inputVec);
count_inv = sort_count_inversion(inputVec,0,9); //considering only the first 10 elements
}
break;
case 2:
{
static const int arr[] = {1, 5, 3, 2, 4, 6};
std::vector<int> inputVec(arr,arr+sizeof(arr)/sizeof(arr[0]));
count_inv = sort_count_inversion(inputVec,0,inputVec.size()-1);
int gh = 0;
}
break;
}
std::cout << "inversions(count): " << count_inv << std::endl;
return 0;
}
void GameState::update(float dt)
{
InputManager* input = getInput();
Kunlaboro::Message msg = sendGlobalQuestion("Get.GameView");
sf::View& gameView = *boost::any_cast<sf::View*>(msg.payload);
bool mode = input->getInput("Mode") > 0.5f;
bool act1 = input->getInput("Action1") > 0.75f;
bool act2 = input->getInput("Action2") > 0.75f;
float up = input->getInput("Up"),
down = input->getInput("Down"),
left = input->getInput("Left"),
right = input->getInput("Right");
if (mode && !mModePressed)
{
mModePressed = true;
std::cerr << "Switching mode to ";
if (mInEditor)
std::cerr << "Game";
else
std::cerr << "Editor";
std::cerr << std::endl;
if (mToneIn == -1)
mToneIn = mInEditor;
mInEditor = !mInEditor;
if (mInEditor && mToneIn == 0)
{
mSnapshot = gameView;
}
}
else if (!mode && mModePressed)
mModePressed = false;
sf::Vector2f currentSize = gameView.getSize();
sf::Vector2f targetSize = currentSize;
float currentAng = gameView.getRotation();
float targetAng = currentAng;
sf::Vector2f currentPos = gameView.getCenter();
sf::Vector2f targetPos = currentPos;
if (mInEditor)
{
if (mToneIn < 1)
{
mToneIn = std::max(0.f, std::min(1.f, mToneIn + dt));
}
sf::Vector2f inputVec(right-left, down-up);
if (act2)
{
mEditorRot += (left - right) * 100 * dt;
mEditorZoom += (down - up) * 150 * dt;
}
else if (act1)
{
}
else
{
if (up > 0.5f || down > 0.5f || left > 0.5f || right > 0.5f)
std::cerr << "TODO: Change selected point" << std::endl;
}
float aspect = currentSize.x/currentSize.y;
targetSize = sf::Vector2f(mEditorZoom * aspect, mEditorZoom);
msg = sendQuestionToEntity(mPlayer, "GetPos");
targetPos = boost::any_cast<sf::Vector2f>(msg.payload);
msg = sendQuestionToEntity(mPlayer, "GetRot");
targetAng = boost::any_cast<float>(msg.payload) + mEditorRot;
}
else
{
if (mToneIn > 0)
{
mToneIn = std::max(0.f, std::min(1.f, mToneIn - dt));
}
targetSize = mSnapshot.getSize();
targetPos = mSnapshot.getCenter();
targetAng = mSnapshot.getRotation();
}
if (mToneIn > 0 && mToneIn < 1)
{
gameView.setSize(currentSize + dt * 3 * (targetSize - currentSize));
gameView.setCenter(currentPos + dt * 3 * (targetPos - currentPos));
gameView.setRotation(slerp(currentAng * deg2rad, targetAng * deg2rad, dt * 3) * rad2deg);
}
else if (mToneIn == 0 || mToneIn == 1)
{
gameView.setCenter(targetPos);
gameView.setSize(targetSize);
gameView.setRotation(targetAng);
mToneIn = -1;
}
if (mInEditor || mToneIn > 0)
setHandled();
}
int main() {
std::mt19937 generator(std::time(nullptr));
sys::ComputeSystem cs;
cs.create(sys::ComputeSystem::_gpu);
sys::ComputeProgram prog;
prog.loadFromFile("resources/neoKernels.cl", cs);
// --------------------------- Create the Sparse Coder ---------------------------
cl::Image2D inputImage = cl::Image2D(cs.getContext(), CL_MEM_READ_WRITE, cl::ImageFormat(CL_R, CL_FLOAT), 4, 4);
std::vector<neo::PredictiveHierarchy::LayerDesc> layerDescs(3);
layerDescs[0]._size = { 16, 16 };
layerDescs[1]._size = { 12, 12 };
layerDescs[2]._size = { 8, 8 };
neo::PredictiveHierarchy ph;
ph.createRandom(cs, prog, { 4, 4 }, 12, layerDescs, { -0.01f, 0.01f }, generator);
std::uniform_int_distribution<int> item_dist(0, 9);
std::vector<float> inputVec(16, 0.0f);
float avg_error = 0.0f;
for (int train_iter = 0; train_iter < 1000; train_iter++) {
std::vector<int> items(10);
for (int show_iter = 0; show_iter < 10; show_iter++) {
items[show_iter] = item_dist(generator);
for (int i = 0; i < 16; i++)
inputVec[i] = 0.0f;
inputVec[items[show_iter]] = 1.0f;
cs.getQueue().enqueueWriteImage(inputImage, CL_TRUE, { 0, 0, 0 }, { 4, 4, 1 }, 0, 0, inputVec.data());
ph.simStep(cs, inputImage);
}
for (int i = 0; i < 16; i++)
inputVec[i] = 0.0f;
cs.getQueue().enqueueWriteImage(inputImage, CL_TRUE, { 0, 0, 0 }, { 4, 4, 1 }, 0, 0, inputVec.data());
for (int wait_iter = 0; wait_iter < 10; wait_iter++) {
ph.simStep(cs, inputImage);
}
// Show delimiter (item = 10)
for (int i = 0; i < 16; i++)
inputVec[i] = 0.0f;
inputVec[10] = 1.0f;
cs.getQueue().enqueueWriteImage(inputImage, CL_TRUE, { 0, 0, 0 }, { 4, 4, 1 }, 0, 0, inputVec.data());
ph.simStep(cs, inputImage);
float error = 0.0f;
std::vector<float> pred(16, 0.0f);
for (int recall_iter = 0; recall_iter < 10; recall_iter++) {
cs.getQueue().enqueueReadImage(ph.getFirstLayerPred().getHiddenStates()[neo::_back], CL_TRUE, { 0, 0, 0 }, { 4, 4, 1 }, 0, 0, pred.data());
for (int i = 0; i < 16; i++) {
if (i == items[recall_iter])
error += std::pow(1.0f - pred[i], 2);
else
error += std::pow(0.0f - pred[i], 2);
}
for (int i = 0; i < 16; i++)
inputVec[i] = 0.0f;
inputVec[items[recall_iter]] = 1.0f;
cs.getQueue().enqueueWriteImage(inputImage, CL_TRUE, { 0, 0, 0 }, { 4, 4, 1 }, 0, 0, inputVec.data());
ph.simStep(cs, inputImage);
}
std::cout << error << std::endl;
}
return 0;
}
