// Function to handle all sorts of things that happen inside this object every tick
void BaseObject::update(std::vector<BaseObject> objects) {
xpos += velX;
ypos += velY;
if (clsn != NULL)
clsn->update(xpos, ypos);
bool hitFloor = false;
for (int i = 0; i < 2; i++) {
if (&objects.at(i) != this) {
if (objects.at(i).isSolid()) {
if (isColliding(objects.at(i).getClsn())) {
if (clsn->bottom >= objects.at(i).getClsn()->top) {
hitFloor = true;
velY = 0;
}
}
}
}
}
if (!hitFloor && gravity > 0) {
velY += gravity;
}
update_animation(); // update sprite animation ticks
for (unsigned int i = 0; i < elements.size(); i++) {
elements.at(i)->run();
}
}
void EffectInstance::change_direction(bool right)
{
if(owner->follow == false) return;
if(current_animation != nullptr){
current_animation->stop();
}
if(right){
current_animation = animation_right;
}else{
current_animation = animation_left;
}
current_animation->jumpToFrame(0);
current_animation->start();
image_width = current_animation->currentImage().width();
image_height = current_animation->currentImage().height();
if(right){
offset = get_location(owner->location_right, owner->center_right);
}else{
offset = get_location(owner->location_left, owner->center_left);
}
update_animation();
}
static void window_load(Window *window) {
Layer *window_layer = window_get_root_layer(window);
layer_set_update_proc(window_layer, update_procs[0]);
s_window_size = layer_get_bounds(window_layer).size;
// start update loop
update_animation(NULL);
}
void gkCharacterNode::update(gkScalar tick)
{
STATE previousTickState = m_currentStateData->m_state;
update_state(tick);
update_animation(previousTickState);
}
/**********************************************************
*
* SUBROUTINE mover()
*
* Used to used to move the movable objects at a set interval
*
*********************************************************/
void mover(int toggle)
{
int i;
update_animation();
// move stars
for ( i = 0; i < NUM_STAR; i++ )
{
if(star[i].z > 3000)
{
star[i].z = -6000;
star[i].x = -3000 + (rand() % 6001);
star[i].y = -2000 + (rand() % 4001);
}
star[i].z = star[i].z + 40;
}
if(jump)
{
if(py < 100)
{
py += 10;
descend = 0;
}
else
{
jump = 0;
descend = 1;
}
}
if(descend)
{
if(py > -10)
{
py -= 10;
jump = 0;
}
else
{
descend = 0;
jump = 0;
}
}
// move enemy
ez = ez + 50;
if(ez > 3000)
{
ez = -6000;
ex = (rand() % 201);
ey = -10;
}
// move road
road_z += 40;
if(road_z > 6000)
{
road_z = -6000;
road_x = 0;
road_y = 0;
}
//move wall make sure that enemy and the walls don't collide
wall_z += 40;
if(wall_z > 3500)
{
wall_z = -6000;
wall_x = (ex + rand()) % 201;
wall_y = -10;
}
// move bullet and check for kill
if(bullet == 1 && space == 1)
{
bz = bz - 300;
if(bz < -7000) bullet = 0;
//check if bullet hit enemy spaceship
if(bx > ex-prs && bx < ex+prs && by > ey-prs && by < ey+prs && bz > ez-200 && bz < ez+200 )
{
fx = 0;
fy = 0;
fz = -12;
ez = 4000;
// make explosion if hit by bullet
flag1++;
if(flag2 - flag1 > 20)
{
CreateExplosion ();
Mix_PlayMusic(blast,0);
score = score + 100;
flag1 = 0;
flag2 = 1;
}
}
}
flag2++;
// Toggle movement
if (toggle>0)
move = !move;
// Increment light position
else
zh = (zh+5)%360;
if(side < 0) side = side + 1;
if(side > 0) side = side - 1;
if(up < 0) up = up + 1;
if(up > 0) up = up - 1;
// Animate flight using Lorenz transform
Ex = -2*dim*Sin(th)*Cos(ph);
Ey = +2*dim *Sin(ph);
Ez = +2*dim*Cos(th)*Cos(ph);
Ox = Oy = Oz = 0;
X = Y = Z = 0;
Dx = 1; Dy = 0; Dz = 0;
Ux = 0; Uy = 1; Uz = 0;
// Set timer to go again
if (move && toggle>=0) glutTimerFunc(50,mover,0);
// Tell GLUT it is necessary to redisplay the scene
glutPostRedisplay();
}
EffectInstance::EffectInstance(Effect *owner, int64_t started, bool right, QWidget *parent)
:QMainWindow(parent), time_started(started), label(this), owner(owner)
{
// Set window properties the same as the pony window
setAttribute(Qt::WA_TranslucentBackground, true);
setAttribute(Qt::WA_ShowWithoutActivating);
#ifdef Q_WS_X11
// Disables shadows under the pony window.
setAttribute(Qt::WA_X11NetWmWindowTypeDock);
#endif
#if defined QT_MAC_USE_COCOA && QT_VERSION >= 0x040800
// Removes shadows that lag behind animation on OS X. QT 4.8+ needed.
setAttribute(Qt::WA_MacNoShadow, true);
#endif
#ifdef QT_MAC_USE_COCOA
// On OS X, tool windows are hidden when another program gains focus.
Qt::WindowFlags windowflags = Qt::FramelessWindowHint;
#else
Qt::WindowFlags windowflags = Qt::FramelessWindowHint | Qt::Tool;
#endif
if(ConfigWindow::getSetting<bool>("general/always-on-top")) {
windowflags |= Qt::WindowStaysOnTopHint;
}
#ifdef Q_WS_X11
if(ConfigWindow::getSetting<bool>("general/bypass-wm")) {
// Bypass the window manager
windowflags |= Qt::X11BypassWindowManagerHint;
}
#endif
setWindowFlags( windowflags );
#ifdef Q_WS_X11
// Qt on X11 does not support the skip taskbar/pager window flags, we have to set them ourselves
// We let Qt initialize the other window properties, which aren't deleted when we replace them with ours
// (they probably are appended on show())
Atom window_state = XInternAtom( QX11Info::display(), "_NET_WM_STATE", False );
Atom window_props[] = {
XInternAtom( QX11Info::display(), "_NET_WM_STATE_SKIP_TASKBAR", False ),
XInternAtom( QX11Info::display(), "_NET_WM_STATE_SKIP_PAGER" , False )
};
XChangeProperty( QX11Info::display(), window()->winId(), window_state, XA_ATOM, 32, PropModeReplace, (unsigned char*)&window_props, 2 );
// Set a null input region mask for the event window, so that it does not interfere with mouseover effects.
XRectangle rect{0,0,0,0};
XserverRegion shapeRegion = XFixesCreateRegion(QX11Info::display(), &rect, 1);
XFixesSetWindowShapeRegion(QX11Info::display(), winId(), ShapeInput, 0, 0, shapeRegion);
XFixesDestroyRegion(QX11Info::display(), shapeRegion);
#endif
// TODO: add WS_EX_TRANSPARENT extended window style on windows.
#ifdef Q_WS_X11
// Make sure the effect gets drawn on the same desktop as the pony
Atom wm_desktop = XInternAtom(QX11Info::display(), "_NET_WM_DESKTOP", False);
Atom type_ret;
int fmt_ret;
unsigned long nitems_ret;
unsigned long bytes_after_ret;
int *desktop = NULL;
if(XGetWindowProperty(QX11Info::display(), owner->parent_pony->window()->winId(), wm_desktop, 0, 1,
False, XA_CARDINAL, &type_ret, &fmt_ret,
&nitems_ret, &bytes_after_ret, reinterpret_cast<unsigned char **>(&desktop))
== Success && desktop != NULL) {
XChangeProperty(QX11Info::display(), window()->winId(), wm_desktop, XA_CARDINAL, 32, PropModeReplace,
reinterpret_cast<unsigned char*>(desktop), 1);
XFree(desktop);
}
#endif
// Load animations and verify them
// TODO: Do we need to change the direction of active effects? Maybe we only need to display the image for the direction at witch it was spawned.
animation_left = new QMovie(QString("%1/%2/%3").arg(ConfigWindow::getSetting<QString>("general/pony-directory"), owner->path, owner->image_left ));
animation_right = new QMovie(QString("%1/%2/%3").arg(ConfigWindow::getSetting<QString>("general/pony-directory"), owner->path, owner->image_right));
if(!animation_left->isValid())
qCritical() << "Effect:"<< owner->path <<"Error opening left animation:"<< owner->image_left << "for effect:"<< owner->name;
if(!animation_right->isValid())
qCritical() << "Effect:"<< owner->path <<"Error opening right animation:"<< owner->image_right << "for behavior:"<< owner->name;
animation_left->setCacheMode(QMovie::CacheAll);
animation_right->setCacheMode(QMovie::CacheAll);
if(right){
current_animation = animation_right;
}else{
current_animation = animation_left;
}
current_animation->jumpToFrame(0);
image_width = current_animation->currentImage().width();
image_height = current_animation->currentImage().height();
if(right){
offset = get_location(owner->location_right, owner->center_right);
}else{
offset = get_location(owner->location_left, owner->center_left);
}
current_animation->start();
update_animation();
show();
}
ENTRYPOINT void
draw_tunnel (ModeInfo *mi)
{
tunnel_configuration *tc = &tconf[MI_SCREEN(mi)];
Display *dpy = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
if (!tc->glx_context)
return;
glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *(tc->glx_context));
glShadeModel(GL_SMOOTH);
glEnable(GL_NORMALIZE);
/* glEnable(GL_CULL_FACE); */
glClear(GL_COLOR_BUFFER_BIT );
update_animation(tc);
glPushMatrix ();
glRotatef(180., 0., 1., 0.);
gltrackball_rotate (tc->trackball);
glRotatef(180., 0., 1., 0.);
mi->polygon_count = 0;
update_fog(tc->effects[4].state[0], /*color*/
tc->effects[4].state[1], /*density*/
tc->effects[4].state[2], /*start*/
tc->effects[4].state[3]); /*end*/
/* --- begin composite image assembly --- */
/* head mask and draw diamond tunnel */
glEnable(GL_BLEND);
draw_cyl(mi, tc, tc->effects[6].state[0], 5, tc->diamondlist, 2);
if (drawlogo)
draw_sign(mi, tc,tc->effects[12].state[0], tc->effects[12].state[1], 1.0 / 1.33, 9, 1);
glDisable(GL_BLEND);
/* then tardis tunnel */
make_wall_tunnel(mi, tc, tc->effects[1].state[0], tc->effects[7].state[0]);
/* then cylinder tunnel */
glEnable(GL_BLEND);
draw_cyl(mi, tc, tc->effects[3].state[0], 2, tc->cyllist, 1);
/*void draw_sign(mi, tc,z,alpha,aspect,tex,blendmode)*/
/* tardis */
if (drawlogo)
draw_sign(mi, tc, tc->effects[2].state[0], tc->effects[2].state[1], 2.0, 1, 0);
/* marquee */
if (drawlogo)
draw_sign(mi, tc, tc->effects[5].state[0], tc->effects[5].state[1], 1.0, 3, 0);
/*who head brite*/
if (drawlogo)
draw_sign(mi, tc,1.0, tc->effects[10].state[0], 1.0 / 1.33, 6, 2);
/*who head psychadelic REMOVED*/
/* draw_sign(mi, tc,1.0, tc->effects[11].state[0], 1.0 / 1.33, 8, 0); */
/* star */
/* draw_sign(mi, tc, tc->effects[8].state[0]tc->effects[8].state[0], 1.0 , 1.0, 4, 1); */
draw_sign(mi, tc, tc->effects[8].state[0], tc->effects[8].state[0], 1.0, 4, 1);
/* normal head */
if (drawlogo)
draw_sign(mi, tc,1.0, tc->effects[9].state[0], 1.0 / 1.33, 6, 0);
/* --- end composite image assembly --- */
glPopMatrix ();
if (mi->fps_p) do_fps (mi);
glFinish();
check_gl_error("drawing done, calling swap buffers");
glXSwapBuffers(dpy, window);
}
/*
* player_update()
* player를 업데이트하는 함수.
*/
void player_update(player_t *player, player_t **team, int team_size, brick_list_t *brick_list, item_list_t *item_list, enemy_list_t *enemy_list)
{
int i;
actor_t *act = player->actor;
float dt = timer_get_delta();
act->hot_spot = v2d_new(image_width(actor_image(act))/2, image_height(actor_image(act))-20);
/* physics */
if(!player->disable_movement) {
player->pa_old_state = physicsactor_get_state(player->pa);
physics_adapter(player, team, team_size, brick_list, item_list, enemy_list);
}
/* player 깜빡거림 */
if(player->blinking) {
player->blink_timer += timer_get_delta();
if(player->blink_timer - player->blink_visibility_timer >= 0.067f) {
player->blink_visibility_timer = player->blink_timer;
act->visible = !act->visible;
}
if(player->blink_timer >= PLAYER_MAX_BLINK) {
player->blinking = FALSE;
act->visible = TRUE;
}
}
if(physicsactor_get_state(player->pa) != PAS_GETTINGHIT && player->pa_old_state == PAS_GETTINGHIT) {
player->blinking = TRUE;
player->blink_timer = 0.0f;
player->blink_visibility_timer = 0.0f;
}
/* 방패 */
if(player->shield_type != SH_NONE)
update_shield(player);
/* 수중에서 */
if(!(player->underwater) && player->actor->position.y >= level_waterlevel())
player_enter_water(player);
else if(player->underwater && player->actor->position.y < level_waterlevel())
player_leave_water(player);
/* 수중인지 확인 */
if(player->underwater) {
player->speedshoes_timer = max(player->speedshoes_timer, PLAYER_MAX_SPEEDSHOES); /* disable speed shoes */
if(player->shield_type != SH_WATERSHIELD)
player->underwater_timer += dt;
else
player->underwater_timer = 0.0f;
if(player_seconds_remaining_to_drown(player) <= 0.0f)
player_drown(player);
}
/* 무적의 별 */
if(player->invincible) {
int maxf = sprite_get_animation("SD_INVSTAR", 0)->frame_count;
int invangle[PLAYER_MAX_INVSTAR];
v2d_t starpos;
player->invtimer += dt;
for(i=0; i<PLAYER_MAX_INVSTAR; i++) {
invangle[i] = (180*4) * timer_get_ticks()*0.001 + (i+1)*(360/PLAYER_MAX_INVSTAR);
starpos.x = 25*cos(invangle[i]*PI/180);
starpos.y = ((timer_get_ticks()+i*400)%2000)/40;
/*starpos = v2d_rotate(starpos, act->angle);*/
player->invstar[i]->position.x = act->position.x - act->hot_spot.x + image_width(actor_image(act))/2 + starpos.x;
player->invstar[i]->position.y = act->position.y - act->hot_spot.y + image_height(actor_image(act)) - starpos.y + 5;
actor_change_animation_frame(player->invstar[i], random(maxf));
}
if(player->invtimer >= PLAYER_MAX_INVINCIBILITY)
player->invincible = FALSE;
}
/* speed shoes */
if(player->got_speedshoes) {
physicsactor_t *pa = player->pa;
if(player->speedshoes_timer == 0) {
physicsactor_set_acc(pa, physicsactor_get_acc(pa) * 2.0f);
physicsactor_set_frc(pa, physicsactor_get_frc(pa) * 2.0f);
physicsactor_set_topspeed(pa, physicsactor_get_topspeed(pa) * 2.0f);
physicsactor_set_air(pa, physicsactor_get_air(pa) * 2.0f);
physicsactor_set_rollfrc(pa, physicsactor_get_rollfrc(pa) * 2.0f);
player->speedshoes_timer += dt;
}
else if(player->speedshoes_timer >= PLAYER_MAX_SPEEDSHOES) {
physicsactor_set_acc(pa, physicsactor_get_acc(pa) / 2.0f);
physicsactor_set_frc(pa, physicsactor_get_frc(pa) / 2.0f);
physicsactor_set_topspeed(pa, physicsactor_get_topspeed(pa) / 2.0f);
physicsactor_set_air(pa, physicsactor_get_air(pa) / 2.0f);
physicsactor_set_rollfrc(pa, physicsactor_get_rollfrc(pa) / 2.0f);
player->got_speedshoes = FALSE;
}
else
player->speedshoes_timer += dt;
}
/* 애니메이션 */
update_animation(player);
/* CPU가 제어하는 player인지 확인 */
if(player != level_player()) {
for(i=0; i<IB_MAX; i++)
input_simulate_button_up(act->input, (inputbutton_t)i);
}
/* 승리 포즈 */
if(level_has_been_cleared())
physicsactor_enable_winning_pose(player->pa);
}
