int createSession(uint32_t *buf, uip_ipaddr_t *addr) {
uint32_t i;
Session_t *session = (Session_t *) (buf + 8);
Session_t *s = (Session_t *) RES_SESSION_LIST; // Pointer auf Flashspeicher
int index = getIndexOf(addr);
// Ein neuer private Key für ECDH wird in jedem Fall generiert
nvm_getVar(buf, RES_ECC_ORDER, LEN_ECC_ORDER);
#if DEBUG
printf("ECC_ORDER: ");
for (i = 0; i < 8; i++) printf("%08X", uip_htonl(buf[i]));
printf("\n");
#endif
do {
random_x((uint8_t *) session->private_key, 32);
} while (!ecc_is_valid_key(session->private_key, buf));
// Falls schon ein Eintrag existiert wird die Session durch
// setzten des neuen private Keys weiterentwickelt. Ansonsten
// wird alles gesetzt.
if (index >= 0) {
nvm_setVar(session->private_key, (fpoint_t) s[index].private_key, 32);
PRINTF("Session aktualisiert:\n");
PRINTSESSION(index);
} else {
index = getIndexOf(NULL);;
if (index < 0)
return -1;
uip_ipaddr_copy(&session->addr, addr);
for (i = 0; i < 8; i++) {
nvm_getVar(session->session + i, RES_ANSCHARS + (random_8() & 0x3F), 1);
} // TODO session-id auf doppel prüfen
session->epoch = 0;
session->valid = 1;
nvm_setVar(session, (fpoint_t) &s[index], sizeof(Session_t));
PRINTF("Session erstellt:\n");
PRINTSESSION(index);
seq_num_r[index] = 1;
seq_num_w[index] = 1;
}
return 0;
}
// Plain Monte Carlo integrator
void MC::plain()
{
// Set volume of sample space
set_volume();
Floattype sum = 0.0f, sumsum = 0.0f, fx;
for (Lengthtype i=0; i<N; ++i) {
x = random_x(); // Random sample point inside intervals
fx = f(x);
sum += fx;
sumsum += fx*fx;
}
Floattype average = sum/N;
Floattype variance = sumsum/N - average*average;
// Write results
Q = average * V;
err = sqrt(variance/N)*V;
}
sgeroids::view::planar::background::object::object(
sge::renderer::device::core &_renderer,
sge::renderer::vertex::declaration const &_vertex_declaration,
sgeroids::view::planar::texture_tree &_texture_tree,
sgeroids::model::play_area const &_play_area,
sgeroids::random_generator &_rng,
star_size const _star_size,
star_count const _star_count)
:
sprite_buffers_(
sge::sprite::buffers::parameters(
_renderer,
_vertex_declaration),
sge::sprite::buffers::option::dynamic),
sprite_collection_(),
sprite_state_(
_renderer,
sge::sprite::state::parameters<
sprite_state_choices
>()),
sprites_(),
sprite_render_range_(),
texture_tree_(
_texture_tree),
play_area_(
_play_area),
star_size_(
_star_size),
star_count_(
_star_count)
{
typedef fcppt::random::distribution::basic<
fcppt::random::distribution::parameters::uniform_int<
int
>
> int_distribution;
typedef fcppt::random::distribution::basic<
fcppt::random::distribution::parameters::uniform_real<
float
>
> float_distribution;
typedef fcppt::random::variate<
sgeroids::random_generator,
int_distribution
> int_rng;
typedef fcppt::random::variate<
sgeroids::random_generator,
float_distribution
> float_rng;
int_rng random_x(
_rng,
int_distribution(
int_distribution::param_type::min(
0),
int_distribution::param_type::max(
play_area_.get().size().w())));
int_rng random_y(
_rng,
int_distribution(
int_distribution::param_type::min(
0),
int_distribution::param_type::max(
play_area_.get().size().h())));
float_rng random_angle(
_rng,
float_distribution(
float_distribution::param_type::min(
0.f),
float_distribution::param_type::sup(
6.f)));
int_rng random_radius(
_rng,
int_distribution(
int_distribution::param_type::min(
math::unit_magnitude() * star_size_.get()),
int_distribution::param_type::max(
math::unit_magnitude() * star_size_.get() * 4)));
for (
star_count::value_type index = 0;
index < star_count_.get();
++index
)
sprites_.push_back(
planar::sprite::object(
sge::sprite::roles::connection{} =
sprite_collection_.connection(
0
),
sge::sprite::roles::texture0{} =
sgeroids::view::planar::sprite::object::texture_type{
texture_tree_.get(
sge::resource_tree::path() / FCPPT_TEXT("star")
)
},
sge::sprite::roles::size{} =
planar::sprite_size_from_texture_and_radius(
*texture_tree_.get(
sge::resource_tree::path() / FCPPT_TEXT("star")),
planar::radius(random_radius())
),
sge::sprite::roles::center{} =
planar::sprite::object::vector(
random_x(),
random_y()
),
sge::sprite::roles::rotation{} =
0.f,
sge::sprite::roles::color{} =
sge::image::color::any::convert<
sgeroids::view::planar::sprite::color_format
>(
sge::image::color::predef::white()
)
)
);
sprites_.push_back(
planar::sprite::object(
sge::sprite::roles::connection{} =
sprite_collection_.connection(
2
),
sge::sprite::roles::texture0{} =
sgeroids::view::planar::sprite::object::texture_type{
texture_tree_.get(
sge::resource_tree::path() / FCPPT_TEXT("planet")
)
},
sge::sprite::roles::size{} =
planar::sprite_size_from_texture_and_radius(
*texture_tree_.get(
sge::resource_tree::path() / FCPPT_TEXT("planet")),
planar::radius(30 * random_radius())
),
sge::sprite::roles::center{} =
planar::sprite::object::vector(
random_x(),
random_y()
),
sge::sprite::roles::rotation{} =
random_angle(),
sge::sprite::roles::color{} =
sge::image::color::any::convert<
sgeroids::view::planar::sprite::color_format
>(
sge::image::color::predef::white()
)
)
);
sprites_.push_back(
planar::sprite::object(
sge::sprite::roles::connection{} =
sprite_collection_.connection(
1
),
sge::sprite::roles::texture0{} =
sgeroids::view::planar::sprite::object::texture_type{
texture_tree_.get(
sge::resource_tree::path() / FCPPT_TEXT("nebula"))
},
sge::sprite::roles::size{} =
planar::sprite_size_from_texture_and_radius(
*texture_tree_.get(
sge::resource_tree::path() / FCPPT_TEXT("nebula")),
planar::radius(math::unit_magnitude() * 1024 * 1024)
),
sge::sprite::roles::center{} =
planar::sprite::object::vector(
random_x(),
random_y()
),
sge::sprite::roles::rotation{} =
random_angle(),
sge::sprite::roles::color{} =
sge::image::color::any::convert<
sgeroids::view::planar::sprite::color_format
>(
sge::image::color::predef::white()
)
)
);
sprite_render_range_ =
sge::sprite::geometry::sort_and_update(
sprite_collection_.range(),
sge::sprite::compare::default_(),
sprite_buffers_);
}
int main()
{
// Patients (n), attributes (p), iterations in solving DP (N1), iterations in estimation of ratio (N2);
int p = 45;
int n = 50;
int N1 = 250;
int N2 = 250;
std::mt19937 generator1 (61245);
std::mt19937 generator2 (16746);
std::mt19937 generator3 (27351);
std::mt19937 generator4 (66459);
std::mt19937 generator5 (12612);
std::mt19937 generator6 (16326);
std::mt19937 generator7 (86733);
std::normal_distribution <double> nd(0.0, 1.0);
std::chi_squared_distribution <double> xs(p - 2);
//R is Cholesky factorization of Covar matrix
//mu is vector of patient attribute means
Eigen::MatrixXd s(p-1,p-1);
Eigen::MatrixXd si(p-1,p-1);
Eigen::MatrixXd zee(n,p-1);
Eigen::MatrixXd Z(n,p-1);
Eigen::MatrixXd Z2(n,p);
//Update mu as necessary
Eigen::VectorXd mu = Eigen::VectorXd::Zero(p-1);
//Generates matrix of standard normals, then uses cholesky factorization to get correct covar matrix
for (int i = 0; i < n; i++){
for (int j = 0; j < p-1; j++){
zee(i,j) = nd(generator1);
}
}
for (int i = 0; i < p-1; i++){
for (int j = 0; j < p-1; j++){
if (i==j)
{
s(i,j) = 1.0;
}
else
{
s(i,j) = 0.1;
}
}
}
si = s.inverse();
Eigen::LLT<Eigen::MatrixXd> lltOfS(s);
Eigen::MatrixXd R = lltOfS.matrixL();
double temp = 0;
//Z2 is matrix of patient attributes (n x p)
Z = zee*R;
for (int i = 0; i < n; i++){
for (int j = 0; j < p; j++){
if(j > 0){
Z2(i,j) = Z(i,j-1) + mu(j-1);
} else{
Z2(i,j) = 1;
}
}
}
//Eta + Xi computation
double eta1 [N1];
double xi1 [N1];
double eta2 [N1];
double xi2 [N1];
for (int i = 0; i < N1; i++){
eta1[i] = nd(generator3)+2;
xi1[i] = xs(generator4);
eta2[i] = nd(generator6)-2;
xi2[i] = xs(generator7);
}
//Solving 2-D DP using mesh
double M = 2000.0;
double delta = 0.2;
int steps = ceil(M/delta)+1;
DP table(n, delta, M);
//syntax helpers
double lambda = 0;
int m = 0;
double lambda_up = 0;
double lambda_down = 0;
double roundup_plus = 0;
double rounddown_plus = 0;
double roundup_minus = 0;
double rounddown_minus = 0;
double distdown_minus = 0;
double distup_minus = 0;
double distdown_plus = 0;
double distup_plus = 0;
double plus = 0;
double minus = 0;
double plus2 = 0;
double minus2 = 0;
int screwups = 0;
//Boundary condition
for (int i = 0; i < 2*n + 1; i++){
for (int j = 0; j < steps;j++){
m = i-n;
lambda = delta*j;
table.set(0, i, j, pow(m, 2) + lambda);
}
}
//Solving mesh
for (int l = 1;l < n; l++){
std::cout << l << "\n";
for (int i = l; i < 2*n+1-l; i++){ //under my indexing, l + k = n
m = i-n;
for (int j = 0; j < steps; j++){
lambda = delta*j;
temp = 0;
for (int iter = 0; iter < N1; iter++){
lambda_up = pow(sqrt(lambda)+eta1[iter],2)+xi1[iter];
lambda_down = pow(sqrt(lambda)-eta1[iter],2)+xi1[iter];
if (lambda_down > M){
lambda_down = M;
}
if (lambda_up > M){
lambda_up = M;
}
roundup_plus = ceil(lambda_up/delta);
rounddown_plus = floor(lambda_up/delta);
distdown_plus = lambda_up - rounddown_plus*delta;
distup_plus = roundup_plus*delta - lambda_up;
roundup_minus = ceil(lambda_down/delta);
rounddown_minus = floor(lambda_down/delta);
distdown_minus = lambda_down - rounddown_minus*delta;
distup_minus = roundup_minus*delta - lambda_down;
try{
plus = (1/delta)*(distup_plus*table.at(l-1, i+1, rounddown_plus) + distdown_plus*table.at(l-1, i+1, roundup_plus));
minus = (1/delta)*(distup_minus*table.at(l-1,i-1,rounddown_minus) + distdown_minus*table.at(l-1,i-1,roundup_minus));
}
catch (const std::out_of_range& e){
std::cout << "roundup/down_plus " << roundup_plus << ", " << rounddown_plus << "\n";
std::cout << "roundup/down_minus " << roundup_minus << ", " << rounddown_minus << "\n";
std::cout << "Line 151 \n";
return 0;
}
lambda_up = pow(sqrt(lambda)+eta2[iter],2)+xi2[iter];
lambda_down = pow(sqrt(lambda)-eta2[iter],2)+xi2[iter];
if (lambda_down > M){
lambda_down = M;
}
if (lambda_up > M){
lambda_up = M;
}
roundup_plus = ceil(lambda_up/delta);
rounddown_plus = floor(lambda_up/delta);
distdown_plus = lambda_up - rounddown_plus*delta;
distup_plus = roundup_plus*delta - lambda_up;
roundup_minus = ceil(lambda_down/delta);
rounddown_minus = floor(lambda_down/delta);
distdown_minus = lambda_down - rounddown_minus*delta;
distup_minus = roundup_minus*delta - lambda_down;
try{
plus += (1/delta)*(distup_plus*table.at(l-1, i+1, rounddown_plus) + distdown_plus*table.at(l-1, i+1, roundup_plus));
minus += (1/delta)*(distup_minus*table.at(l-1,i-1,rounddown_minus) + distdown_minus*table.at(l-1,i-1,roundup_minus));
}
catch (const std::out_of_range& e){
std::cout << "roundup/down_plus " << roundup_plus << ", " << rounddown_plus << "\n";
std::cout << "roundup/down_minus " << roundup_minus << ", " << rounddown_minus << "\n";
std::cout << "Line 151 \n";
return 0;
}
temp = temp*iter/(iter+1) + std::min(plus,minus)/(iter+1);
/*if(temp < 0){
std::cout << lambda_down << " " << lambda_up << "\n";
std::cout << distdown_plus << " " << distup_plus << "\n";
std::cout << distdown_minus << " " << distup_minus << "\n";
return 0;
}*/
}
try{
table.set(l,i,j,temp);
}
catch (const std::out_of_range& e){
std::cout << "(" << l << ", " << i << ", " << j <<") \n";
}
}
}
}
char result[ PATH_MAX ];
ssize_t count = readlink( "/proc/self/exe", result, PATH_MAX );
std::string name = std::string( result, (count > 0) ? count : 0);
std::string extension = ".csv";
name.append(extension);
std::ofstream outputFile;
outputFile.open(name);
//for (int l = 0; l < n; l++){
for (int l = 0; l < n; l++){
for (int i=0; i < 2*n+1;i++){
for (int j=0; j < 1; j++){
outputFile << table.at(l,i,j) << ", ";
}
//outputFile << "\n";
}
outputFile << "\n";
}
outputFile.close();
return 0;
//Vs Naive random allocation
//Eff = x^T P_Z x where x is allocations, P_Z = I - Z(Z^T Z)^(-1) Z^T
Eigen::MatrixXd PZ;
Eigen::MatrixXd I = Eigen::MatrixXd::Identity(n,n);
Eigen::MatrixXd Z2I;
//Generates matrix of standard normals, then uses cholesky factorization to get correct covar matrix
//Vector of n/2 1's and -1's
int rand_x[n];
for (int i = 0; i < n; i++){
rand_x[i] = -1 + 2*floor(2*i/n);
}
std::vector <int> myvector (rand_x, rand_x+n);
Eigen::VectorXd random_x(n);
Eigen::VectorXd dp_x(n);
double eff_r = 0;
double eff_dp = 0;
double eff = 0;
//Tracks variable Delta as in paper
Eigen::VectorXd var_Delta(p-1);
var_Delta.setZero();
Eigen::VectorXd var_Delta_up(p-1);
Eigen::VectorXd var_Delta_down(p-1);
Eigen::MatrixXd condition(n,n); //Used to prevent floating point problems
int var_delta;
double mahalanobis_plus = 0;
double mahalanobis_minus = 0;
//Eigen::EigenSolver<Eigen::MatrixXd> es;
//Large loop to test policies
for (int asdf = 0; asdf < N2; asdf++){
//std::cout << "asdf = " << asdf << "\n";
var_delta = n;
var_Delta.setZero();
for (int i = 0; i < n; i++){
for (int j = 0; j < p-1; j++){
zee(i,j) = nd(generator1);
}
}
//Z is matrix of patient attributes (n x p)
Z = zee*R;
for (int i = 0; i < n; i++){
for (int j = 0; j < p; j++){
if(j > 0){
Z2(i,j) = Z(i,j-1) + mu(j-1);
} else{
Z2(i,j) = 1;
}
}
}
Z2I = Z2.transpose()*Z2;
PZ = I - Z2*(Z2I.inverse())*Z2.transpose();
//es.compute(PZ, false);
//temp = 0;
//for (int i = 0; i < n; i++){
// if (temp > (double)(es.eigenvalues()(i,0).real())){
// temp = (double)(es.eigenvalues()(i,0).real());
// }
//}
//PZ = PZ + Eigen::MatrixXd::Identity(n,n)*temp;
//This is where randomized sampling is done
for (int i = 0; i < N1; i++){
std::random_shuffle ( myvector.begin(), myvector.end());
for (int j = 0; j < n; j++){
random_x(j) = myvector[j];
}
temp = random_x.transpose() * PZ * random_x;
eff_r = eff_r*i/(i+1) + temp/(i+1);
}
//This is where we do "optimal" sampling
for (int i = 0; i < n; i++){
std::cout << Z2.block(i,1,1,p-1) << "\n";
var_Delta_up = var_Delta + Z2.block(i,1,1,p-1).transpose();
std::cout << var_Delta_up.transpose() << "\n";
var_Delta_down = var_Delta - Z2.block(i,1,1,p-1).transpose();
std::cout << var_Delta_down.transpose() << "\n";
mahalanobis_plus = var_Delta_up.transpose()*si*var_Delta_up;
std::cout << mahalanobis_plus << "\n";
roundup_plus = ceil(mahalanobis_plus/delta);
rounddown_plus = floor(mahalanobis_plus/delta );
distup_plus = roundup_plus*delta - mahalanobis_plus;
distdown_plus = mahalanobis_plus - rounddown_plus*delta;
//std::cout << var_delta << "\n";
//std::cout << rounddown_plus << " " << roundup_plus << "\n";
//std::cout << "(" << n-i-1 << "," << var_delta+1 << ", " << rounddown_plus << ") \n";
//std::cout << "plus done \n";
mahalanobis_minus = var_Delta_down.transpose()*si*var_Delta_down;
roundup_minus = ceil(mahalanobis_minus/delta );
rounddown_minus = floor(mahalanobis_minus/delta);
distup_minus = roundup_minus*delta - mahalanobis_minus;
distdown_minus = mahalanobis_minus - rounddown_minus*delta;
//std::cout << "(" << n-i-1 << "," << var_delta-1 << ", " << rounddown_plus << ") \n";
try{
plus = (1/delta)*(distup_plus*table.at(n-1-i,var_delta+1, rounddown_plus) + distdown_plus*table.at(n-1-i,var_delta+1,roundup_plus));
minus = (1/delta)*(distup_minus*table.at(n-1-i,var_delta-1, rounddown_minus) + distdown_minus*table.at(n-1-i,var_delta-1,roundup_minus));
if (minus > plus){
var_delta++;
var_Delta = var_Delta_up;
dp_x(i) = 1;
} else{
var_delta--;
var_Delta = var_Delta_down;
dp_x(i) = -1;
}
}
catch (const std::out_of_range& e){
std::cout << "mahalanobis_plus = " << mahalanobis_plus << "\n";
std::cout << "mahalanobis_minus = " << mahalanobis_minus << "\n";
std::cout << "distdown/up plus =" << distdown_plus << ", " << distup_plus << "\n";
std::cout << "distdown/up minus =" << distdown_minus << ", " << distup_minus << "\n";
std::cout << "line 273 \n";
std::cout << asdf << "\n";
screwups++;
}
std::cout << "Press any key to continue.";
std::cin.get();
}
eff_dp = dp_x.transpose()*PZ*dp_x;
std::cout << eff_r << ", " << eff_dp << "\n";
temp += eff_dp/eff_r;
eff = eff*asdf/(asdf+1) + (eff_dp/eff_r)/(asdf+1);
}
std::cout << temp/(N1-screwups) << "\n";
std::cout << "screwups = " << screwups << "\n";
std::cout << eff << "\n";
//std::cout << "\n" << PZ << "\n";
//std::cout << "\n" << eff_r << "\n \n" << eff_dp << "\n";
//std::cout << "\n" << dp_x << "\n \n" << dp_x.transpose()*PZ*dp_x;
//Eigen::EigenSolver<Eigen::MatrixXd> es;
//es.compute(PZ);
//std::cout << "\n" << es.eigenvalues();
}
void CPlayState::Update(CGameEngine* game)
{
sf::Vector2u window_size = game->window.getSize();
//System Constants
unsigned WINDOW_WIDTH = window_size.x;
unsigned WINDOW_HEIGHT = window_size.y;
unsigned FPS = 60;
double PI = 3.14159265;
//Window Settings
/*
sf::ContextSettings settings;
settings.antialiasingLevel = 8;
sf::RenderWindow window(sf::VideoMode(WINDOW_WIDTH, WINDOW_HEIGHT), "Runner", sf::Style::Default, settings);
window.setVerticalSyncEnabled(true);
*/
sf::RenderWindow& window = game->window;
double lastFrameTimeStamp = GetTickCount(); // GetTickCount is for Windows only
double frame_length = 1000/FPS;
//random generator
std::default_random_engine rand_generator;
rand_generator.seed(time(0)); // seed will only change once per second
std::uniform_int_distribution<unsigned> random_x(25,WINDOW_WIDTH-25);
std::uniform_int_distribution<unsigned> random_y(25,WINDOW_HEIGHT-25);
//-----------------------------------
//LOAD SOUND FILES
sf::SoundBuffer buffer;
if (!buffer.loadFromFile("eat.wav")) {
//error loading file
}
sf::Sound eatsound;
eatsound.setBuffer(buffer);
eatsound.setVolume(30);
sf::SoundBuffer buffer2;
if (!buffer2.loadFromFile("gameover.wav")) {
//error loading file
}
sf::Sound gameoversound;
gameoversound.setBuffer(buffer2);
gameoversound.setVolume(30);
//-----------------------------------
//LOAD FONT AND TEXT
//Set Default font and text settings
sf::Font font;
font.loadFromFile("arial.ttf");
sf::Text default_text_settings;
default_text_settings.setFont(font);
default_text_settings.setColor(sf::Color(254,255,221,100));
default_text_settings.setStyle(sf::Text::Bold);
default_text_settings.setCharacterSize(24);
sf::Text displayscore = default_text_settings;
displayscore.setPosition(500,50);
//--------------------------------------
//INITIALIZE GAME OBJECTS
//game variables
bool collision = false;
bool game_running = true;
double snake_speed = game->m_GameMode.getGameSpeed();
std::string gamespeed = "normal";
unsigned directional_speed = 10;
double hitbox = 2.2;
unsigned score = 0;
if(game->m_GameMode.getGameSpeed() == .30) {
gamespeed = "fast";
directional_speed = 15;
hitbox = 3.3;
}
//snake
unsigned snake_width = 10;
unsigned snake_height = 10;
int snake_length = 0;
float snake_direction = 0;
sf::Vector2f snake_coord;
//snake head
sf::RectangleShape snake(sf::Vector2f(snake_width*2, snake_height*2));
snake.setPosition(WINDOW_WIDTH/2, WINDOW_HEIGHT/2);
snake.setOrigin(snake_width, snake_height);
//snake head
sf::Texture snakehead;
if (!snakehead.loadFromFile("snake_head.gif")) {
// error...
}
snakehead.setSmooth(true);
snake.setTexture(&snakehead);
//snake skin
sf::Texture snaketexture;
if (!snaketexture.loadFromFile("snake_skin.gif")) {
// error...
}
snaketexture.setSmooth(true);
//snake.setTexture(&snaketexture);
//snake body
std::deque<sf::RectangleShape> snake_body{};
sf::Vector2f snake_body_coord;
//store past snake coordinates
std::queue<sf::Vector2f> snake_history;
//food
sf::RectangleShape food(sf::Vector2f(6, 6));
food.setFillColor(sf::Color(255,153,0));
food.setPosition(random_x(rand_generator), random_y(rand_generator));
sf::Vector2f food_coord;
//background
sf::Texture bgtexture;
if (!bgtexture.loadFromFile("grassbackground2.jpg",sf::IntRect(0,0,640,480))) {
//error
}
sf::Sprite bgsprite;
bgsprite.setTexture(bgtexture);
//---------------------------------------
//GAME LOOP
while(game_running)
{
double currentTimeStamp = GetTickCount();
if(currentTimeStamp - lastFrameTimeStamp >= frame_length)
{
//EVENT HANDLER
sf::Event event;
while (window.pollEvent(event))
{
switch (event.type)
{
case sf::Event::Closed:
window.close();
game->Quit();
break;
}
}
//USER INPUT HANDLER
if(game->m_ControlMode.getControlType() == "keyboard") {
if (sf::Keyboard::isKeyPressed(sf::Keyboard::Left)) {
snake_direction -= directional_speed;// move left
}
if (sf::Keyboard::isKeyPressed(sf::Keyboard::Right)) {
snake_direction += directional_speed; // move right
}
}
if(game->m_ControlMode.getControlType() == "mouse") {
if (sf::Mouse::isButtonPressed(sf::Mouse::Left)) {
snake_direction -= directional_speed; // move left
}
if (sf::Mouse::isButtonPressed(sf::Mouse::Right)) {
snake_direction += directional_speed;// move right
}
}
//GAME LOGIC
//store past coordinates
snake_coord = snake.getPosition();
snake_history.push(snake_coord);
//limit size of history queue so it doesn't grow too large
if (snake_history.size() > snake_length + 10)
{
snake_history.pop();
}
//Create new snake shape
sf::RectangleShape snake_temp(sf::Vector2f(snake_width, snake_height));
//snake_temp.setFillColor(sf::Color(128,128,0));
snake_temp.setPosition(snake_history.back());
snake_temp.setOrigin(snake_width/2, snake_height/2);
snake_temp.setTexture(&snaketexture);
//Add new temporary snake shape to vector
snake_body.push_back(snake_temp);
//remove oldest snake shape from snake body if snake did not grow
if(snake_body.size() > snake_length)
{
snake_body.pop_front();
}
//change snake head angle
snake.setRotation(snake_direction);
//move snake head forward
snake.move((snake_speed * frame_length)*sin(snake_direction * PI / 180),
(snake_speed * frame_length)*-cos(snake_direction * PI / 180));
//check if snake hit edge of window
snake_coord = snake.getPosition();
if(snake_coord.x - snake_width < 0)
{
std::cout<< "Game Over: left edge hit" << std::endl;
collision = true;
}
if(snake_coord.y - snake_height < 0)
{
std::cout<< "Game Over: top edge hit" << std::endl;
collision = true;
}
if(snake_coord.x + snake_width > WINDOW_WIDTH)
{
std::cout<< "Game Over: right edge hit" << std::endl;
collision = true;
}
if(snake_coord.y + snake_height> WINDOW_HEIGHT)
{
std::cout<< "Game Over: bottom edge hit" << std::endl;
collision = true;
}
//SURVIVAL GAME MODE
if(game->m_GameMode.getGameType() == "survival") {
snake_length++;
}
//check if snake ate food
snake_coord = snake.getPosition();
food_coord = food.getPosition();
if ((snake_coord.x <= food_coord.x + snake_width) &&
(snake_coord.x >= food_coord.x - snake_width) &&
(snake_coord.y <= food_coord.y + snake_height) &&
(snake_coord.y >= food_coord.y - snake_height))
{
food.setPosition(random_x(rand_generator), random_y(rand_generator));
snake_length += 5;
eatsound.play();
score++;
}
//check for snake head and snake body collision
for(std::deque<sf::RectangleShape>::size_type i = 0; i != snake_body.size(); i++) {
snake_body_coord = snake_body[i].getPosition();
if ((snake_coord.x <= snake_body_coord.x + hitbox) &&
(snake_coord.x >= snake_body_coord.x - hitbox) &&
(snake_coord.y <= snake_body_coord.y + hitbox) &&
(snake_coord.y >= snake_body_coord.y - hitbox)) {
std::cout << "Game Over: Collision with body piece: #" << i << std::endl;
collision = true;
break;
}
}
//GAME OVER CONDITION
if (collision) {
gameoversound.play();
//Store the score in the file
std::ofstream file;
file.open ("highscores.txt", std::ios_base::app | std::ios_base::out);
file << game->m_GameMode.getGameType() << "," << gamespeed << "," << score << "\r";
file.close();
Sleep(1000);
game_running = false;
game->PopState();
game->PopState();
break;
}
std::ostringstream ss;
ss << score;
displayscore.setString( std::string( "Score: "+ss.str() ) );
//RENDER
window.clear();
window.draw(bgsprite);
for(std::deque<sf::RectangleShape>::size_type i = snake_body.size(); i != 0; --i) {
window.draw(snake_body[i-1]); //i != vector.size
}
window.draw(snake); //head drawn after body so it is on top
window.draw(food);
window.draw(displayscore);
window.display();
lastFrameTimeStamp = currentTimeStamp;
//DEBUG
//std::cout << snake_body.size();
}
Sleep(1); // saves some cpu
} //end core game loop
}
