void sys_control_movement::update(entity &e) {
auto &m = e.C(com_movement);
auto &c = e.C(com_control);
auto &b = e.C(com_box);
auto &g = e.C(com_gravity);
// control com_movement
float speed = 0.2;
float save_speed = 0;
const float backwards = 0.6;
if (save_speed != 0) {
speed = save_speed;
save_speed = 0;
}
if (g.in_gravity) speed *= 2.5;
if (c.bl) {
m.vel.x += sin(b.angle + M_PI) * speed;
m.vel.y += cos(b.angle) * speed;
}
if (c.br) {
m.vel.x += sin(b.angle + M_PI) * speed;
m.vel.y += cos(b.angle) * speed;
}
if (c.tl) {
m.vel.x -= sin(b.angle + M_PI) * speed * backwards;
m.vel.y -= cos(b.angle) * speed * backwards;
}
if (c.tr) {
m.vel.x -= sin(b.angle + M_PI) * speed * backwards;
m.vel.y -= cos(b.angle) * speed * backwards;
}
if (g.in_gravity) {
m.friction = 0.9;
} else {
if (!c.bl && !c.br && !c.tl && !c.tr) {
m.friction = 0.92f;
} else {
m.friction = 1.0f;
}
float max_speed = 5.0f;
if ((c.tl && c.tr) || (c.br && c.bl)) max_speed *= 1.4;
if (c.tl || c.tr) max_speed *= backwards;
float speed = vdistance(vec2(0), m.vel);
float boost_speed = vdistance(vec2(0), g.boost_vel);
if (boost_speed > max_speed) max_speed = boost_speed;
if (speed > max_speed) m.vel = normalize(m.vel) * max_speed;
g.boost_vel = normalize(g.boost_vel) * (boost_speed - 0.22);
}
}
void sandpit::update() {
// pool::get().coll.light_up();
pool::get().coll.clear();
// pool::get().coll.draw_border();
auto planets = get_entities<ent_planet>();
for (auto &p : planets) {
pool::get().draw("gravity.png").pos(p->C(com_box).pos);
}
world::update();
parallax->update(&get_entity<ent_hero>());
// draw space background
// for (int i = -1; i < 2; ++i) {
// for (int j = -1; j < 2; ++j) {
sprite &space_bg = pool::get().draw("background.png");
space_bg.pos(vec2(space_bg.size.w / 2 + 300, space_bg.size.h / 2 + 300));
space_bg.index(1);
// pool::get().draw("border.png").pos(0).index(1);
// }
//}
// draw debug statements
ent_hero &h = get_entity<ent_hero>();
auto &hb = h.C(com_box);
auto &hm = h.C(com_movement);
auto &hg = h.C(com_gravity);
vector<string> debug_statements = {
"position: (" + to_string(hb.pos.x) + ", " + to_string(hb.pos.y) + ")",
"angle: " + to_string(hb.angle), "angular velocity: " + to_string(hm.angular_velocity),
"velocity: (" + to_string(hm.vel.x) + ", " + to_string(hm.vel.y) + ")",
"speed: " + to_string(vdistance(vec2(0), hm.vel)),
"orbit: (" + to_string(hg.orbit.x) + ", " + to_string(hg.orbit.y) + ")",
"orbit speed: " + to_string(vdistance(vec2(0), hg.orbit))};
vec2 start_pos(10, pool::get().screen.h + 10);
for (auto &s : debug_statements) {
start_pos.y -= 40;
pool::get().draw_text("font.ttf", 30, s, start_pos);
}
pool::get().draw_text("font.ttf", 30, to_string(frame_time), vec2(10, 28));
}
int find_closest_centroid_index(int ec, int dc, centroid_t *ctrd, data_t *data)
{
int i, j, idx = 0;
double mv = 1000., tmp;
for (i = 0; i < ec; i++)
{
for (j = 0, tmp = 0.; j < ctrd->dimsize; j++)
tmp += vdistance(ctrd[i].raw[j], data[dc].raw[j]);
if (tmp < mv)
mv = tmp, idx = i;
}
return idx;
}
//deperated
void sample_mean_variance(int a, double* _s_mean, double* _s_var, record_t* _y_nor)
{
int i;
double mean, var;
for (i = 0, mean = 0.0; i < a; i++)
mean += _y_nor[i].value;
mean /= a;
for (i = 0, var = 0.0; i < a; i++)
var += vdistance(_y_nor[i].value, mean);
var /= (a - 1);
*_s_mean = mean;
*_s_var = var;
}
void sys_homing_missiles::pew_pew(entity *e) {
auto &b = e->C(com_box);
// auto &r = e.C(com_radius);
// TODO get only nearby enemies
vector<entity *> enemies = w->get_entities("enemy");
// ivec2 p = pool::get().coll.point_at_pos(b.pos);
// vector<ivec2> points;
// points.push_back(p);
// points.push_back({p.x + 1, p.y});
// points.push_back({p.x, p.y + 1});
// points.push_back({p.x + 1, p.y + 1});
// points.push_back({p.x - 1, p.y});
// points.push_back({p.x, p.y - 1});
// points.push_back({p.x - 1, p.y - 1});
// points.push_back({p.x + 1, p.y - 1});
// points.push_back({p.x - 1, p.y + 1});
// vector<entity *> enemies = pool::get().coll.get_surrounding(points, "enemy");
entity *closest = nullptr;
float closest_distance = 0.0;
for (entity *enemy : enemies) {
float cur_distance = vdistance(b.pos, enemy->C(com_box).pos);
if (closest == nullptr || cur_distance < closest_distance) {
closest = enemy;
closest_distance = cur_distance;
}
}
if (closest != nullptr && closest_distance < 500 / 2) {
// auto &m = e.C(com_movement);
// m.vel += normalize(b.pos - closest->C(com_box).pos) * 1;
cout << "launching missile" << endl;
// audio_engine::set_host(sfx_pew, &b.pos);
// audio_engine::play_sound(sfx_pew);
// vec2 observer = w->get_entity<ent_hero>().C(com_box).pos;
audio_engine::play_sound("lasersound.wav");
auto &missile = w->add_entity<ent_missile>();
missile.C(com_box).pos = b.pos;
}
}
/*각 centroid와 모든 data간의 euclidean distance를 계산해서
각 centroid의 pdfweight 와 cpon_range
각 data의 pdf에 저장*/
void setPDF(int ec, int clst_s, int cdd_c, centroid_t *ctrd, dataparam_t *dataparam)
{
int i, j, k;
double x;
for (i = 0; i < clst_s; i++)
ctrd[i].pdfweight[cdd_c] = 1.0 / (clst_s * exp(dataparam->dimsize * log(ctrd[ec].cpon_range[cdd_c].sigma * sqrt(2.0 * PI))));
for (i = 0; i < dataparam->datasize; i++)
{
dataparam->pdf_tr[i] = 0.;
for (j = 0; j < clst_s; j++)
{
x = 0.;
for (k = 0; k < ctrd->dimsize; k++)
x += vdistance(dataparam->data[i].raw[k], ctrd[j].raw[k]);
dataparam->pdf_tr[i] += ctrd[j].pdfweight[cdd_c] *
exp(-x / (2.0 * ctrd[j].cpon_range[cdd_c].sigma * ctrd[j].cpon_range[cdd_c].sigma));
// printf("%lf %lf is %s\n", *(((ctrd + j)->pdfweight) + cdd_c), ctrd[j].pdfweight[cdd_c], *(((ctrd + j)->pdfweight) + cdd_c) == ctrd[j].pdfweight[cdd_c] ? "same" : "diffrent");
}
}
}
void setDimentionRange(int f, int c, int t, oneclass_t* db)
{
static int i, j;
static double x, y;
dimparam_t* table_dim = db->table_dimparam[f][c][t];
int datasize = db->table_dataparam[f][c][t].datasize;
data_t* table_data = db->table_dataparam[f][c][t].data;
if (db == NULL) return;
/* calculating the variances of data */
for (j = 0; j < db->dimsize; j++)
{
for (x = 0., i = 0; i < datasize; i++)
x += table_data[i].raw[j];
x /= datasize;
for (y = 0., i = 0; i < datasize; i++)
y += vdistance(table_data[i].raw[j], x);
y /= (datasize - 1);//sample이기 때문에
table_dim[j].mean = x;
table_dim[j].variance = y;
}
}
int getLBGClusterSize(int f, int c, int ec, oneclass_t *db)
{
int i, j, u;
int closest_ctrd_i;
centroid_t *centroid = db->table_centroid[f][c][0];
dimparam_t *dimparam = db->table_dimparam[f][c][0];
dataparam_t *dataparam = &db->table_dataparam[f][c][0];
centroid->var_max = 0.;//기존 프로그램에서는 호출될 때마다 초기화 되던데요?
if (db->isRRD)
{
for (i = 0; i < ec; i++)
for (j = 0; j < centroid->dimsize; j++)
centroid[i].raw[j] = centroid[i].seedRaw[j];
}
else
{
srand(ec);
for (i = 0; i < ec; i++)
for (j = 0; j < centroid->dimsize; j++)
centroid[i].raw[j] = centroid[i].seedRaw[j] = sqrt(dimparam[j].variance) * (2.0 * rand() / RAND_MAX - 1.0) + dimparam[j].mean;
}
//centroid의 dimension parameter들 초기화 해줍니다...이거땜시 나흘을 버렸어!!!
for (i = 0; i < ec; i++)
for (j = 0; j < centroid->dimsize; j++)
centroid[i].dimparam[j].mean = centroid[i].dimparam[j].variance = 0.;
for (u = 0; u < CLUSTERING_COUNT; u++)
{
for (i = 0; i < ec; i++)
{
centroid[i].datasize = 0;
for (j = 0; j < dataparam->dimsize; j++)
centroid[i].dimweight[j] = 0.;
}
for (i = 0; i < dataparam->datasize; i++)
{
closest_ctrd_i = find_closest_centroid_index(ec, i, centroid, dataparam->data);
for (j = 0; j < centroid->dimsize; j++)
centroid[closest_ctrd_i].dimweight[j] += dataparam->data[i].raw[j];
((*(centroid + closest_ctrd_i)).datasize)++;
}
for (i = 0; i < ec; i++)
for (j = 0; j < dataparam->dimsize; j++)
{
centroid[i].raw[j] = centroid[i].dimweight[j];
if (centroid[i].datasize > CNTR_IGNORE_SIZE)
centroid[i].raw[j] /= centroid[i].datasize;
}
}
fprintf(db->flf[f], "centroid size : %d\n", ec);
fprintf(db->flf[f], "ctrd no.\tdatasize\tworktype\t");
for (i = 0; i < db->dimsize; fprintf(db->flf[f], "raw[%d]%c", i++, db->dimsize - i == 1 ? '\n' : '\t'));
//cluster 결과를 log로 남기기 위한 코드입니다.
for (i = 0; i < ec; i++)
{
fprintf(db->flf[f], "\t\tseed\t");
for (j = 0; j < db->dimsize; fprintf(db->flf[f], "%lf%c", centroid[i].seedRaw[j++], db->dimsize - j == 1? '\n' : '\t'));
fprintf(db->flf[f], "%d\t%d\tclst\t", i, centroid[i].datasize);
for (j = 0; j < db->dimsize; fprintf(db->flf[f], "%lf%c", centroid[i].raw[j++], db->dimsize - j == 1 ? '\n' : '\t'));
}
//set dimension parameter of centroids
for (i = 0; i < dataparam->datasize; i++)
{
closest_ctrd_i = find_closest_centroid_index(ec, i, centroid, dataparam->data);
for (j = 0; j < dataparam->dimsize; j++)
{
centroid[closest_ctrd_i].dimparam[j].variance += vdistance(dataparam->data[i].raw[j], centroid[closest_ctrd_i].raw[j]);
centroid[closest_ctrd_i].dimparam[j].mean += dataparam->data[i].raw[j];
}
}
for (i = 0; i < ec; i++)
{
if ((*(centroid + i)).datasize > CNTR_IGNORE_SIZE)
{
for (j = 0; j < dataparam->dimsize; j++)
{
centroid[i].dimparam[j].variance /= (centroid[i].datasize - 1);
centroid[i].dimparam[j].mean /= centroid[i].datasize;
}
}
}
for (i = 0; i < ec; i++)
{
for (j = 0; j < dataparam->dimsize; j++)
{
if (centroid[i].datasize > CNTR_IGNORE_SIZE && centroid[i].dimparam[j].variance > centroid->var_max)
centroid->var_max = centroid[i].dimparam[j].variance;//varmax is share variable
}
}
for (i = 0, j = 0; i < ec; i++)
if (centroid[i].datasize > CNTR_IGNORE_SIZE) j++;
// for (i = 0; i < ec; i++)
// printf("%d:%d, ", i, (*(centroid + i)).datasize);
return j;
}
