// Machinegun void actorMachineGun (edict_t *self) { vec3_t start, target; vec3_t forward, right, up; int damage; if(!self->enemy || !self->enemy->inuse) { self->monsterinfo.pausetime = 0; return; } AngleVectors (self->s.angles, forward, right, up); G_ProjectSource2 (self->s.origin, self->muzzle, forward, right, up, start); ActorTarget(self,target); VectorSubtract (target, start, forward); VectorNormalize (forward); if(self->monsterinfo.aiflags & AI_TWO_GUNS) damage = 2; else damage = 4; fire_bullet (self, start, forward, damage, 2, DEFAULT_BULLET_HSPREAD, DEFAULT_BULLET_VSPREAD, MOD_MACHINEGUN); gi.WriteByte(svc_temp_entity); gi.WriteByte(TE_CHAINFIST_SMOKE); gi.WritePosition(start); gi.multicast(start, MULTICAST_PVS); gi.positioned_sound(start,self,CHAN_WEAPON,gi.soundindex(va("weapons/machgf%db.wav",self->actor_gunframe % 5 + 1)),1,ATTN_NORM,0); if(self->flash) { VectorCopy(start,self->flash->s.origin); self->flash->think = muzzleflash_think; self->flash->wait = level.time + FRAMETIME; self->flash->think(self->flash); } if(developer->value) TraceAimPoint(start,target); if(self->monsterinfo.aiflags & AI_TWO_GUNS) { G_ProjectSource2 (self->s.origin, self->muzzle2, forward, right, up, start); ActorTarget(self,target); VectorSubtract (target, start, forward); VectorNormalize (forward); fire_bullet (self, start, forward, damage, 2, DEFAULT_BULLET_HSPREAD, DEFAULT_BULLET_VSPREAD, MOD_MACHINEGUN); gi.WriteByte(svc_temp_entity); gi.WriteByte(TE_CHAINFIST_SMOKE); gi.WritePosition(start); gi.multicast(start, MULTICAST_PVS); } }
void fire_bullet_ang(struct moag *m, char type, int x, int y, float angle, float vel) { fire_bullet(m, type, (float)x + 5.0 * cosf(DEG2RAD(angle)), (float)y - 5.0 * sinf(DEG2RAD(angle)), vel * cosf(DEG2RAD(angle)), -vel * sinf(DEG2RAD(angle))); }
//FIXME mosnters should call these with a totally accurate direction // and we can mess it up based on skill. Spread should be for normal // and we can tighten or loosen based on skill. We could muck with // the damages too, but I'm not sure that's such a good idea. void monster_fire_bullet (edict_t *self, vec3_t start, vec3_t dir, int damage, int kick, int hspread, int vspread, int flashtype) { float chance; // holy freeze reduces firing rate by 50% if (que_typeexists(self->curses, AURA_HOLYFREEZE)) { if (random() <= 0.5) return; } // chill effect reduces attack rate/refire if (self->chill_time > level.time) { chance = 1 / (1 + CHILL_DEFAULT_BASE + CHILL_DEFAULT_ADDON * self->chill_level); if (random() > chance) return; } damage = monster_increaseDamageByTalent(self->activator, damage); fire_bullet (self, start, dir, damage, kick, hspread, vspread, MOD_UNKNOWN); gi.WriteByte (svc_muzzleflash2); gi.WriteShort (self - g_edicts); gi.WriteByte (flashtype); gi.multicast (start, MULTICAST_PVS); }
//FIXME mosnters should call these with a totally accurate direction // and we can mess it up based on skill. Spread should be for normal // and we can tighten or loosen based on skill. We could muck with // the damages too, but I'm not sure that's such a good idea. void monster_fire_bullet(edict_t *self, vec3_t start, vec3_t dir, int damage, int kick, int hspread, int vspread, int flashtype){ fire_bullet(self, start, dir, damage, kick, hspread, vspread, MOD_UNKNOWN); gi.WriteByte(svc_muzzleflash2); gi.WriteShort(self - g_edicts); gi.WriteByte(flashtype); gi.multicast(start, MULTICAST_PVS); }
void teclado(char **nomes, int side) { int c; /**Contador para respeitar mintshoot**/ contador=0; /**ponderar verificar check dead no servidor*/ while (!quit) { /**SE DEAD, espera por confirmacao do servidor(?)*/ lock(&actualiza); lock(&ecra); c = getch(); switch(c) { case 'w': case KEY_UP: move_cowboy_up(nomes, side, &cowboys[side].sfd); break; case 's': case KEY_DOWN: move_cowboy_down(nomes, side, &cowboys[side].sfd); break; case ' ': /**So envio se tiver balas disponiveis*/ /**BLOQUEAR ACESSO!*/ if (cowboys[side].bulletsleft && !contador) { /**Para se dar inicio à contagem*/ contador++; fire_bullet( nomes, side, &cowboys[side].sfd); } break; case 'q': inicia_saida(nomes[PID], &cowboys[side].sfd, side); quit = 1; break; case 'a': break; break; } /**Assim que atinge mintshoot para contagem e mantem valor zero*/ if(contador) contador=(contador+1)%mintshoot; unlock(&actualiza); unlock(&ecra); } }
void timer_update(struct moag *m, int id) { struct timer *t = &m->timers[id]; if (t->frame && t->frame <= m->frame) { fire_bullet(m, t->type, t->x, t->y, t->vx, t->vy); t->frame = 0; } }
// Willi void Shrapnel_Explode (edict_t *ent) { vec3_t origin; vec3_t grenade1; vec3_t grenade2; vec3_t grenade3; vec3_t grenade4; vec3_t grenade5; vec3_t grenade6; vec3_t grenade7; vec3_t grenade8; int mod; int i; vec3_t offset; if (ent->owner->client) PlayerNoise(ent->owner, ent->s.origin, PNOISE_IMPACT); VectorSet(offset,0,0,32); VectorAdd(offset,ent->s.origin,offset); VectorCopy (offset, ent->s.origin); VectorSet(grenade1,20,20,5); VectorSet(grenade2,20,-20,5); VectorSet(grenade3,-20,20,5); VectorSet(grenade4,-20,-20,5); VectorSet(grenade5,0,20,5); VectorSet(grenade6,0,-20,5); VectorSet(grenade7,-20,0,5); VectorSet(grenade8,20,0,5); for (i = 0; i < 6; i++) { fire_bullet (ent, offset, grenade1, 2, 2, 4500, 4500, MOD_G_SPLASH); fire_bullet (ent, offset, grenade2, 2, 2, 4500, 4500, MOD_G_SPLASH); fire_bullet (ent, offset, grenade3, 2, 2, 4500, 4500, MOD_G_SPLASH); fire_bullet (ent, offset, grenade4, 2, 2, 4500, 4500, MOD_G_SPLASH); fire_bullet (ent, offset, grenade5, 2, 2, 4500, 4500, MOD_G_SPLASH); fire_bullet (ent, offset, grenade6, 2, 2, 4500, 4500, MOD_G_SPLASH); fire_bullet (ent, offset, grenade7, 2, 2, 4500, 4500, MOD_G_SPLASH); fire_bullet (ent, offset, grenade8, 2, 2, 4500, 4500, MOD_G_SPLASH); } Grenade_Explode (ent); }
void monster_autocannon_fire(edict_t *self) { vec3_t forward, right, start; // fire straight ahead AngleVectors (self->s.angles, forward, right, NULL); if (self->onFloor) VectorNegate(right, right); VectorMA(self->s.origin, 24, forward, start); G_ProjectSource (self->s.origin, fireOffset[self->style], forward, right, start); if(EMPNukeCheck(self, start)) { gi.sound (self, CHAN_AUTO, gi.soundindex("items/empnuke/emp_missfire.wav"), 1, ATTN_NORM, 0); return; } // what to fire? switch(self->style) { case 1: default: fire_bullet(self, start, forward, AC_BULLET_DMG, AC_BULLET_KICK, DEFAULT_BULLET_HSPREAD, DEFAULT_BULLET_VSPREAD, MOD_AUTOCANNON); gi.WriteByte (svc_muzzleflash); gi.WriteShort (self - g_edicts); gi.WriteByte (MZ_CHAINGUN2); gi.multicast (self->s.origin, MULTICAST_PVS); break; case 2: fire_rocket(self, start, forward, AC_ROCKET_DMG, AC_ROCKET_SPEED, AC_ROCKET_RADIUS_DMG, AC_ROCKET_DMG_RADIUS); gi.WriteByte (svc_muzzleflash); gi.WriteShort (self - g_edicts); gi.WriteByte (MZ_ROCKET); gi.multicast (self->s.origin, MULTICAST_PVS); break; case 3: case 4: fire_blaster (self, start, forward, AC_BLASTER_DMG, AC_BLASTER_SPEED, EF_HYPERBLASTER, true); gi.WriteByte (svc_muzzleflash); gi.WriteShort (self - g_edicts); gi.WriteByte (MZ_HYPERBLASTER); gi.multicast (self->s.origin, MULTICAST_PVS); break; } }
void Machinegun_Fire (edict_t *ent) { int i; vec3_t start; vec3_t forward, right; vec3_t angles; int damage = 8; int kick = 2; vec3_t offset; if (!(ent->client->buttons & BUTTON_ATTACK)) { ent->client->machinegun_shots = 0; ent->client->ps.gunframe++; return; } if (ent->client->ps.gunframe == 5) ent->client->ps.gunframe = 4; else ent->client->ps.gunframe = 5; if (ent->client->inventory[ent->client->ammo_index] < 1) { ent->client->ps.gunframe = 6; if (level.framenum >= ent->pain_debounce_framenum) { gi.sound(ent, CHAN_VOICE, gi.soundindex("weapons/noammo.wav"), 1, ATTN_NORM, 0); ent->pain_debounce_framenum = level.framenum + SECS_TO_FRAMES(1); } NoAmmoWeaponChange (ent); return; } if (is_quad == ent) { damage *= 4; kick *= 4; } for (i=1 ; i<3 ; i++) { ent->client->kick_origin_final[i] = crandom() * 0.35f; ent->client->kick_angles_final[i] = crandom() * 0.7f; } ent->client->kick_origin_final[0] = crandom() * 0.35f; ent->client->kick_angles_final[0] = ent->client->machinegun_shots * -1.5f; ent->client->kick_origin_start = 0; ent->client->kick_origin_end = 0.1f * SERVER_FPS; // get start / end positions VectorAdd (ent->client->v_angle, ent->client->kick_angles_final, angles); AngleVectors (angles, forward, right, NULL); VectorSet(offset, 0, 8, ent->viewheight-8); P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start); fire_bullet (ent, start, forward, damage, kick, DEFAULT_BULLET_HSPREAD, DEFAULT_BULLET_VSPREAD, MOD_MACHINEGUN); TDM_WeaponFired (ent); gi.WriteByte (svc_muzzleflash); gi.WriteShort (ent-g_edicts); gi.WriteByte (MZ_MACHINEGUN | is_silenced); gi.multicast (ent->s.origin, MULTICAST_PVS); if (! ( (int)dmflags->value & DF_INFINITE_AMMO ) ) ent->client->inventory[ent->client->ammo_index]--; ent->client->anim_priority = ANIM_ATTACK; if (ent->client->ps.pmove.pm_flags & PMF_DUCKED) { ent->s.frame = FRAME_crattak1 - (int) (random()+0.25f); ent->client->anim_end = FRAME_crattak9; } else { ent->s.frame = FRAME_attack1 - (int) (random()+0.25f); ent->client->anim_end = FRAME_attack8; } }
void Chaingun_Fire (edict_t *ent) { int shots, flash_shots = 1; vec3_t start; vec3_t forward, right, up; float r, u; vec3_t offset; int damage; int kick = 0; int item = getWornItem(ent, GIEX_ITEM_WEAPON); iteminfo_t *info = getWornItemInfo(ent, 0); int i, spread = getMachinegunSpread(ent, item, info); // damage = info->arg1 + info->arg2 * ent->client->pers.skill[1]; damage = getChaingunDamage(ent, item, info); if (ent->client->ps.gunframe == 5) { if ((ent->client->silencer_shots > 0) && (ent->client->pers.skill[58] > 6)) { ent->client->silencer_shots -= 1; } else { gi.sound(ent, CHAN_AUTO, gi.soundindex("weapons/chngnu1a.wav"), 1, ATTN_IDLE, 0); } ent->client->ps.gunframe += ent->client->pers.skill[5]; } if ((ent->client->ps.gunframe == 14) && !(ent->client->buttons & BUTTON_ATTACK)) { ent->client->ps.gunframe = 32; // End firing ent->client->weapon_sound = 0; return; } else if ((ent->client->ps.gunframe == 21) && (ent->client->buttons & BUTTON_ATTACK) && ent->client->pers.inventory[ent->client->ammo_index]) { ent->client->ps.gunframe = 15; // Loop back } else { ent->client->ps.gunframe++; } if (ent->client->ps.gunframe == 22) { ent->client->weapon_sound = 0; if ((ent->client->silencer_shots > 0) && (ent->client->pers.skill[58] > 6)) { ent->client->silencer_shots -= 1; } else { gi.sound(ent, CHAN_AUTO, gi.soundindex("weapons/chngnd1a.wav"), 1, ATTN_IDLE, 0); } ent->client->ps.gunframe += ent->client->pers.skill[5]; } else { if ((ent->client->silencer_shots > 0) && (ent->client->pers.skill[58] > 6)) { ent->client->silencer_shots -= 1; } else { ent->client->weapon_sound = gi.soundindex("weapons/chngnl1a.wav"); } } ent->client->anim_priority = ANIM_ATTACK; if (ent->client->ps.pmove.pm_flags & PMF_DUCKED) { ent->s.frame = FRAME_crattak1 - (ent->client->ps.gunframe & 1); ent->client->anim_end = FRAME_crattak9; } else { ent->s.frame = FRAME_attack1 - (ent->client->ps.gunframe & 1); ent->client->anim_end = FRAME_attack8; } if (ent->client->ps.gunframe <= 9) { shots = info->arg4; } else if (ent->client->ps.gunframe <= 14) { if (ent->client->buttons & BUTTON_ATTACK) { shots = info->arg4 + 1; flash_shots = 2; } else { shots = info->arg4; flash_shots = 1; } } else { // 15 - 20 if ((ent->client->ps.gunframe == 18) || (ent->client->ps.gunframe == 20)) { shots = info->arg4 + 2; flash_shots = 2; } else { shots = info->arg4 + 1; flash_shots = 1; } } if (shots < 1) shots = 1; if (ent->client->pers.inventory[ent->client->ammo_index] < shots) { shots = ent->client->pers.inventory[ent->client->ammo_index]; } if (!shots) { if (level.time >= ent->pain_debounce_time) { gi.sound(ent, CHAN_VOICE, gi.soundindex("weapons/noammo.wav"), 1, ATTN_NORM, 0); ent->pain_debounce_time = level.time + 1; } NoAmmoWeaponChange (ent); return; } damage = applyWeaponBonuses(ent, damage, 1); // if (is_quad) // kick *= 4; for (i=0 ; i<3 ; i++) { ent->client->kick_origin[i] = crandom() * 0.35; ent->client->kick_angles[i] = crandom() * 0.7; } for (i=0 ; i<shots ; i++) { // get start / end positions AngleVectors (ent->client->v_angle, forward, right, up); r = 7 + crandom()*4; u = crandom()*4; VectorSet(offset, 0, r, u + ent->viewheight-8); P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start); fire_bullet (ent, start, forward, damage, kick, spread, spread, MOD_CHAINGUN); } // send muzzle flash if ((ent->client->silencer_shots > 0) && (ent->client->pers.skill[58] > 7)) { ent->client->silencer_shots -= shots; } else { gi.WriteByte (svc_muzzleflash); gi.WriteShort (ent-g_edicts); gi.WriteByte ((MZ_CHAINGUN1 + flash_shots) | is_silenced); gi.multicast (ent->s.origin, MULTICAST_PVS); } ent->client->silencer_shots-=3; PlayerNoise(ent, start, PNOISE_WEAPON); // if (! ( (int)dmflags->value & DF_INFINITE_AMMO ) ) ent->client->pers.inventory[ent->client->ammo_index] -= shots; }
void Machinegun_Fire (edict_t *ent) { vec3_t start; vec3_t forward, right; vec3_t angles; int damage; int kick = 0; vec3_t offset; int item = getWornItem(ent, GIEX_ITEM_WEAPON); iteminfo_t *info = getWornItemInfo(ent, GIEX_ITEM_WEAPON); int i, spread = getMachinegunSpread(ent, item, info); // damage = info->arg1 + info->arg2 * ent->client->pers.skill[1]; damage = getMachinegunDamage(ent, item, info); if (!(ent->client->buttons & BUTTON_ATTACK)) { ent->client->ps.gunframe++; return; } if (ent->client->ps.gunframe == 5) ent->client->ps.gunframe = 4; else ent->client->ps.gunframe = 5; if (ent->client->pers.inventory[ent->client->ammo_index] < 1) { ent->client->ps.gunframe = 6; if (level.time >= ent->pain_debounce_time) { gi.sound(ent, CHAN_VOICE, gi.soundindex("weapons/noammo.wav"), 1, ATTN_NORM, 0); ent->pain_debounce_time = level.time + 1; } NoAmmoWeaponChange (ent); return; } damage = applyWeaponBonuses(ent, damage, 1); // if (is_quad) // kick *= 4; for (i=1 ; i<3 ; i++) { ent->client->kick_origin[i] = crandom() * 0.35; ent->client->kick_angles[i] = crandom() * 0.7; } ent->client->kick_origin[0] = crandom() * 0.35; // get start / end positions VectorAdd (ent->client->v_angle, ent->client->kick_angles, angles); AngleVectors (angles, forward, right, NULL); VectorSet(offset, 0, 8, ent->viewheight-8); P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start); fire_bullet (ent, start, forward, damage, kick, spread, spread, MOD_MACHINEGUN); if ((ent->client->silencer_shots > 0) && (ent->client->pers.skill[58] > 7)) { ent->client->silencer_shots -= 1; } else { gi.WriteByte (svc_muzzleflash); gi.WriteShort (ent-g_edicts); gi.WriteByte (MZ_MACHINEGUN | is_silenced); gi.multicast (ent->s.origin, MULTICAST_PVS); } PlayerNoise(ent, start, PNOISE_WEAPON); // if (! ( (int)dmflags->value & DF_INFINITE_AMMO ) ) ent->client->pers.inventory[ent->client->ammo_index]--; ent->client->anim_priority = ANIM_ATTACK; if (ent->client->ps.pmove.pm_flags & PMF_DUCKED) { ent->s.frame = FRAME_crattak1 - (int) (random()+0.25); ent->client->anim_end = FRAME_crattak9; } else { ent->s.frame = FRAME_attack1 - (int) (random()+0.25); ent->client->anim_end = FRAME_attack8; } }
void Ship::update(){ sf::Vector2f accel(0,0); if (sf::Keyboard::isKeyPressed(sf::Keyboard::Left) || sf::Keyboard::isKeyPressed(sf::Keyboard::A)) { m_rotation-=m_rotation_speed; } if (sf::Keyboard::isKeyPressed(sf::Keyboard::Right) || sf::Keyboard::isKeyPressed(sf::Keyboard::D)) { m_rotation+=m_rotation_speed; } m_shape->setRotation(m_rotation); float theta = DEGREES_TO_RADIANS(m_rotation); float cs = cos(theta); float sn = sin(theta); if (sf::Keyboard::isKeyPressed(sf::Keyboard::Up) || sf::Keyboard::isKeyPressed(sf::Keyboard::W)) { sf::Vector2f thrust = *m_acceleration; accel+=thrust; // rotate the vector sf::Vector2f newAccel; newAccel.x = accel.x * cs - accel.y * sn; newAccel.y = accel.x * sn + accel.y * cs; *m_velocity+=newAccel; if (Funcs::GetVecLen(*m_velocity) > m_max_speed) *m_velocity=Funcs::Normalise(*m_velocity)*m_max_speed; } else { if (Funcs::GetVecLen(*m_velocity) > 0.01f) { //slow by using reverse vector sf::Vector2f negVel = *m_velocity * 0.05f; *m_velocity = *m_velocity - negVel; } else { *m_velocity=sf::Vector2f(0.f,0.f); } } //bounds checking /*if (m_pos->x > m_windowsize[0] - m_length/2) m_pos->x = (m_windowsize[0] - m_length/2); else if (m_pos->x < m_length/2) m_pos->x = m_length/2; if (m_pos->y > m_windowsize[1] - m_length/2) m_pos->y = (m_windowsize[1] - m_length/2); else if (m_pos->y < m_length/2) m_pos->y = m_length/2;*/ if (m_pos->x < 0-m_length/2) m_pos->x = m_windowsize[0]+m_length/2; else if (m_pos->x > m_windowsize[0]+m_length/2) m_pos->x = 0-m_length/2; if (m_pos->y < 0-m_length/2) m_pos->y = m_windowsize[1]+m_length/2; else if (m_pos->y > m_windowsize[1]+m_length/2) m_pos->y = 0-m_length/2; //set position *m_pos+=*m_velocity; m_shape->setPosition(*m_pos); if (sf::Mouse::isButtonPressed(sf::Mouse::Left) && !m_firing) { // if the mouse is clicked, use mouse position for shot sf::Vector2f position = (sf::Vector2f)sf::Mouse::getPosition(*m_window); position-=*m_pos; fire_bullet(position); m_firing = true; m_timer = m_shoot_time; } if (sf::Keyboard::isKeyPressed(sf::Keyboard::Space) && !m_firing) { // if space is pressed, use ship direction for shot sf::Vector2f dir(0,1); sf::Vector2f rotdir; rotdir.x = dir.x * cs - dir.y * sn; rotdir.y = dir.x * sn + dir.y * cs; fire_bullet(rotdir); m_firing = true; m_timer = m_shoot_time; } if (!sf::Mouse::isButtonPressed(sf::Mouse::Left) && !sf::Keyboard::isKeyPressed(sf::Keyboard::Space)) { m_firing = false; } if (m_timer > 0) { m_timer--; } else if (m_timer == 0) { m_firing = false; } vector<Bullet>::iterator it; for (it = m_bullet_vec->begin(); it != m_bullet_vec->end(); ++it) { if ((*it).isAlive()) (*it).update(); else { //remove dead bullets, decrement the iterator m_bullet_vec->erase(it); --it; } } }
int main(int argc, char const *argv[]) { const int FPS = 60; const int MAX_BULLETS = 10; const int MAX_ASTEROIDS = 10; const int MAX_EXPLOSIONS = 10; srand(time(NULL)); int done = 0; int redraw = 1; if(!al_init()) { al_show_native_message_box(NULL, "Error", "Error", "Could not initialize Allegro 5.", 0, ALLEGRO_MESSAGEBOX_ERROR); return -1; } ALLEGRO_DISPLAY *display = al_create_display(screen_width, screen_height); if(!display) { al_show_native_message_box(NULL, "Error", "Error", "Could not create display.", 0, ALLEGRO_MESSAGEBOX_ERROR); return -1; } ALLEGRO_EVENT_QUEUE *event_queue = al_create_event_queue(); if(!event_queue) { al_show_native_message_box(display, "Error", "Error", "Could not create event queue.", 0, ALLEGRO_MESSAGEBOX_ERROR); return -1; } ALLEGRO_TIMER *timer = al_create_timer(1.0/FPS); if(!timer) { al_show_native_message_box(display, "Error", "Error", "Could not create timer.", 0, ALLEGRO_MESSAGEBOX_ERROR); return -1; } if(!al_install_keyboard()) { al_show_native_message_box(display, "Error", "Error", "Could not install keyboard.", 0, ALLEGRO_MESSAGEBOX_ERROR); return -1; } if(!al_install_mouse()) { al_show_native_message_box(display, "Error", "Error", "Could not install mouse.", 0, ALLEGRO_MESSAGEBOX_ERROR); return -1; } if(!al_init_image_addon()) { al_show_native_message_box(display, "Error", "Error", "Could not initialize image addon.", 0, ALLEGRO_MESSAGEBOX_ERROR); return -1; } if(!al_init_primitives_addon()) { al_show_native_message_box(display, "Error", "Error", "Could not initialize primitives addon.", 0, ALLEGRO_MESSAGEBOX_ERROR); } al_init_font_addon(); // for whatever reason this function is void returning if(!al_init_ttf_addon()) { al_show_native_message_box(display, "Error", "Error", "Could not initialize ttf addon.", 0, ALLEGRO_MESSAGEBOX_ERROR); } al_hide_mouse_cursor(display); al_register_event_source(event_queue, al_get_mouse_event_source()); al_register_event_source(event_queue, al_get_keyboard_event_source()); al_register_event_source(event_queue, al_get_display_event_source(display)); al_register_event_source(event_queue, al_get_timer_event_source(timer)); ALLEGRO_FONT *font18 = al_load_font("Arial.ttf", 18, 0); int prev_x = screen_width, prev_y = screen_height; int fps_counter = 0; int fps_counter2 = 0; int i, j, k; struct spaceship ship; init_ship(&ship); struct bullet bullets[MAX_BULLETS]; for(i = 0; i < MAX_BULLETS; i++) { init_bullet(&bullets[i]); } struct asteroid asteroids[MAX_ASTEROIDS]; for(i = 0; i < MAX_ASTEROIDS; i++) { init_asteroid(&asteroids[i]); } struct explosion explosions[MAX_EXPLOSIONS]; for(i = 0; i < MAX_EXPLOSIONS; i++) { init_explosion(&explosions[i]); } al_start_timer(timer); while(!done) { ALLEGRO_EVENT event; al_wait_for_event(event_queue, &event); if(event.type == ALLEGRO_EVENT_DISPLAY_CLOSE) { done = 1; } if(event.type == ALLEGRO_EVENT_KEY_DOWN) { switch(event.keyboard.keycode) { case ALLEGRO_KEY_Q: done = 1; break; case ALLEGRO_KEY_ESCAPE: done = 1; break; } } if(event.type == ALLEGRO_EVENT_MOUSE_BUTTON_DOWN) { if(event.mouse.button & 1) { for(i = 0; i < MAX_BULLETS; i++) { if(!bullets[i].live) { fire_bullet(&bullets[i], ship); break; } } } } if(event.type == ALLEGRO_EVENT_MOUSE_AXES || event.type == ALLEGRO_EVENT_MOUSE_ENTER_DISPLAY) { set_ship_coordinates(&ship, event.mouse.x, event.mouse.y); } if(event.type == ALLEGRO_EVENT_TIMER) { if(ship.x > prev_x) { ship.sprite.dir_horizontal = RIGHT; } else if(ship.x == prev_x) { ship.sprite.dir_horizontal = CENTER; } else if(ship.x < prev_x) { ship.sprite.dir_horizontal = LEFT; } if(ship.y > prev_y) { ship.sprite.dir_vertical = BACK; } else if(ship.y == prev_y) { ship.sprite.dir_vertical = NEUTRAL; } else if(ship.y < prev_y) { ship.sprite.dir_vertical = FORWARD; } if(++fps_counter >= FPS / 5) { fps_counter = 0; prev_x = ship.x; prev_y = ship.y; } if(++fps_counter2 >= 2 * FPS) { for(i = 0; i < MAX_ASTEROIDS; i++) { if(!asteroids[i].live) { start_asteroid(&asteroids[i]); break; } } fps_counter2 = 0; } for(i = 0; i < MAX_BULLETS; i++) { if(bullets[i].live) { update_bullet(&bullets[i]); } } for(i = 0; i < MAX_ASTEROIDS; i++) { if(asteroids[i].live) { update_asteroid(&asteroids[i], &ship); } } for(i = 0; i < MAX_EXPLOSIONS; i++) { if(explosions[i].live) { update_explosion(&explosions[i]); } } update_ship_boundaries(&ship); for(i = 0; i < MAX_BULLETS; i++) { if(bullets[i].live) { for(j = 0; j < MAX_ASTEROIDS; j++) { if(asteroids[j].live) { if(bullet_and_asteroid_collision(bullets[i], asteroids[j])) { bullets[i].live = 0; asteroids[j].live = 0; ship.score += 20; for(k = 0; k < MAX_EXPLOSIONS; k++) { if(!explosions[k].live) { start_explosion(&explosions[k], bullets[i].x, bullets[i].y); break; } } } } } } } for(i = 0; i < MAX_ASTEROIDS; i++) { if(asteroids[i].live) { if(ship_and_asteroid_collision(ship, asteroids[i])) { asteroids[i].live = 0; for(k = 0; k < MAX_EXPLOSIONS; k++) { if(!explosions[k].live) { start_explosion(&explosions[k], ship.x, ship.y); break; } } ship.lives--; } } } if(!ship.lives) { done = true; } redraw = 1; } if(redraw) { redraw = 0; draw_ship_sprite(ship.sprite, ship.x, ship.y); for(i = 0; i < MAX_BULLETS; i++) { if(bullets[i].live) { draw_bullet(bullets[i]); } } for(i = 0; i < MAX_ASTEROIDS; i++) { if(asteroids[i].live) { draw_asteroid(asteroids[i]); } } for(i = 0; i < MAX_EXPLOSIONS; i++) { if(explosions[i].live) { draw_explosion(explosions[i]); } } al_draw_textf(font18, al_map_rgb(255, 255, 255), 50, 5, 0, "Score: %d ", ship.score); // I have no idea why it doesn't print the S... al_draw_textf(font18, al_map_rgb(255, 255, 255), 50, 25, 0, "Lives: %d", ship.lives); al_flip_display(); al_clear_to_color(al_map_rgb(0, 0, 0)); } } for(i = 0; i < MAX_ASTEROIDS; i++) { destroy_asteroid(&asteroids[i]); } for(i = 0; i < MAX_EXPLOSIONS; i++) { destroy_explosion(&explosions[i]); } destroy_sprite(&ship.sprite); al_destroy_display(display); al_destroy_event_queue(event_queue); al_destroy_timer(timer); al_destroy_font(font18); return 0; }
// Chaingun void actorChaingun (edict_t *self) { vec3_t start, target; vec3_t forward, right, up; int i; int shots; int damage; if(!self->enemy || !self->enemy->inuse) self->monsterinfo.pausetime = 0; if(level.time >= self->monsterinfo.pausetime) { self->s.sound = 0; gi.sound(self,CHAN_AUTO,gi.soundindex("weapons/chngnd1a.wav"),1,ATTN_IDLE,0); return; } if(self->actor_gunframe == 0) gi.sound(self, CHAN_AUTO, gi.soundindex("weapons/chngnu1a.wav"), 1, ATTN_IDLE, 0); if(self->actor_gunframe == 21 && level.time < self->monsterinfo.pausetime) self->actor_gunframe = 15; else self->actor_gunframe++; self->s.sound = gi.soundindex("weapons/chngnl1a.wav"); #ifdef LOOP_SOUND_ATTENUATION self->s.attenuation = ATTN_IDLE; #endif if(self->actor_gunframe <= 9) shots = 1; else if(self->actor_gunframe <= 14) shots = 2; else shots = 3; AngleVectors (self->s.angles, forward, right, up); G_ProjectSource2 (self->s.origin, self->muzzle, forward, right, up, start); ActorTarget(self,target); VectorSubtract (target, start, forward); VectorNormalize (forward); if(self->monsterinfo.aiflags & AI_TWO_GUNS) damage = 2; else damage = 4; for(i=0; i<shots; i++) fire_bullet (self, start, forward, damage, 2, DEFAULT_BULLET_HSPREAD, DEFAULT_BULLET_VSPREAD, MOD_CHAINGUN); gi.WriteByte(svc_temp_entity); gi.WriteByte(TE_CHAINFIST_SMOKE); gi.WritePosition(start); gi.multicast(start, MULTICAST_PVS); gi.positioned_sound(start,self,CHAN_WEAPON,gi.soundindex(va("weapons/machgf%db.wav",self->actor_gunframe % 5 + 1)),1,ATTN_NORM,0); if(self->flash) { VectorCopy(start,self->flash->s.origin); self->flash->think = muzzleflash_think; self->flash->wait = level.time + FRAMETIME; self->flash->think(self->flash); } if(developer->value) TraceAimPoint(start,target); if(self->monsterinfo.aiflags & AI_TWO_GUNS) { G_ProjectSource2 (self->s.origin, self->muzzle2, forward, right, up, start); ActorTarget(self,target); VectorSubtract (target, start, forward); VectorNormalize (forward); for(i=0; i<shots; i++) fire_bullet (self, start, forward, damage, 2, DEFAULT_BULLET_HSPREAD, DEFAULT_BULLET_VSPREAD, MOD_CHAINGUN); gi.WriteByte(svc_temp_entity); gi.WriteByte(TE_CHAINFIST_SMOKE); gi.WritePosition(start); gi.multicast(start, MULTICAST_PVS); } }
void Chaingun_Fire (edict_t *ent) { int i; int shots; vec3_t start; vec3_t forward, right, up; float r, u; vec3_t offset; int damage; int kick = 2; if (deathmatch->value) damage = 6; else damage = 8; if (ent->client->ps.gunframe == 5) gi.sound(ent, CHAN_AUTO, gi.soundindex("weapons/chngnu1a.wav"), 1, ATTN_IDLE, 0); if ((ent->client->ps.gunframe == 14) && !(ent->client->buttons & BUTTON_ATTACK)) { ent->client->ps.gunframe = 32; ent->client->weapon_sound = 0; return; } else if ((ent->client->ps.gunframe == 21) && (ent->client->buttons & BUTTON_ATTACK) && ent->client->pers.inventory[ent->client->ammo_index]) { ent->client->ps.gunframe = 15; } else { ent->client->ps.gunframe++; } if (ent->client->ps.gunframe == 22) { ent->client->weapon_sound = 0; gi.sound(ent, CHAN_AUTO, gi.soundindex("weapons/chngnd1a.wav"), 1, ATTN_IDLE, 0); } else { ent->client->weapon_sound = gi.soundindex("weapons/chngnl1a.wav"); } ent->client->anim_priority = ANIM_ATTACK; if (ent->client->ps.pmove.pm_flags & PMF_DUCKED) { ent->s.frame = FRAME_crattak1 - (ent->client->ps.gunframe & 1); ent->client->anim_end = FRAME_crattak9; } else { ent->s.frame = FRAME_attack1 - (ent->client->ps.gunframe & 1); ent->client->anim_end = FRAME_attack8; } if (ent->client->ps.gunframe <= 9) shots = 1; else if (ent->client->ps.gunframe <= 14) { if (ent->client->buttons & BUTTON_ATTACK) shots = 2; else shots = 1; } else shots = 3; if (ent->client->pers.inventory[ent->client->ammo_index] < shots) shots = ent->client->pers.inventory[ent->client->ammo_index]; if (!shots) { if (level.time >= ent->pain_debounce_time) { gi.sound(ent, CHAN_VOICE, gi.soundindex("weapons/noammo.wav"), 1, ATTN_NORM, 0); ent->pain_debounce_time = level.time + 1; } NoAmmoWeaponChange (ent); return; } if (is_quad) { damage *= 4; kick *= 4; } for (i=0 ; i<3 ; i++) { ent->client->kick_origin[i] = crandom() * 0.35; ent->client->kick_angles[i] = crandom() * 0.7; } for (i=0 ; i<shots ; i++) { // get start / end positions AngleVectors (ent->client->v_angle, forward, right, up); r = 7 + crandom()*4; u = crandom()*4; VectorSet(offset, 0, r, u + ent->viewheight-8); P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start); fire_bullet (ent, start, forward, damage, kick, DEFAULT_BULLET_HSPREAD, DEFAULT_BULLET_VSPREAD, MOD_CHAINGUN); } // send muzzle flash gi.WriteByte (svc_muzzleflash); gi.WriteShort (ent-g_edicts); gi.WriteByte ((MZ_CHAINGUN1 + shots - 1) | is_silenced); gi.multicast (ent->s.origin, MULTICAST_PVS); PlayerNoise(ent, start, PNOISE_WEAPON); if (! ( (int)dmflags->value & DF_INFINITE_AMMO ) ) ent->client->pers.inventory[ent->client->ammo_index] -= shots; }
void update_ship(Ship *s) { if (keys.left){ if (s->vrot < 7) s->vrot += s->arot; } if (keys.right){ if (s->vrot > -7) s->vrot -= s->arot; } if (keys.space){ fire_bullet(s); keys.space = 0; } if (keys.up){ Vector *v = get_unit_vector(s->rot); s->v->x += v->x / 10; s->v->y += v->y / 10; free(v); add_smoke(s); } //update ship if (s->vrot){ s->vrot *= 0.95; s->rot += s->vrot; s->rot %= 360; if (s->rot < 0) s->rot +=360; rotate_sprite(s->sprite, s->rot_buffer, s->rot); } s->v->x *= 0.95; s->v->y *= 0.95; s->pos->x += s->v->x; s->pos->y += s->v->y; if (s->pos->x < 0) s->pos->x = 0; if (s->pos->x + s->sprite.w > s->rainbow->w) s->pos->x = s->rainbow->w - s->sprite.w; if (s->pos->y < 0) s->pos->y = 0; if (s->pos->y + s->sprite.h > s->rainbow->h) s->pos->y = s->rainbow->h - s->sprite.h; //update bullets int i; for (i = 0; i < vl_array_length(s->bullets); ++i){ Bullet* b = ((Bullet*) get_element(s->bullets, i)); b->x += (int)b->vx; b->y += (int)b->vy; if (point_offscreen (s->rainbow, b->x, b->y) || point_offscreen(s->rainbow, b->x + b->w, b->y + b->h)){ remove_element(s->bullets, b); --i; } } // update particles for (i = 0; i < vl_array_length(s->particles); ++i){ Particle *p = (Particle*) get_element(s->particles, i); --(p->life); p->pos->x += p->v->x; p->pos->y += p->v->y; if (p->life < 0 || point_offscreen(s->rainbow, p->pos->x, p->pos->y)) { free(p->pos); free(p->v); remove_element(s->particles, p); --i; continue; } } }
int main(void) { bool done =false; bool redraw = true; ALLEGRO_DISPLAY *display = NULL; ALLEGRO_TIMER *timer =NULL; ALLEGRO_EVENT_QUEUE *event_queue = NULL; SpaceShip ship; Bullet bullet[num_bullets]; Commet commet[num_commets]; if(!al_init()) { fprintf(stderr,"allegro is not intialized"); return -1; } display = al_create_display(SCREEN_W,SCREEN_H); if(!display) { fprintf(stderr,"failed to intialize the display"); return -1; } timer = al_create_timer(1.0/FPS); if(!timer) { fprintf(stderr,"failed to intialize timer"); al_destroy_display(display); return -1; } event_queue = al_create_event_queue(); if(!event_queue) { fprintf(stderr,"failed to create event queue"); al_destroy_display(display); al_destroy_timer(timer); return -1; } al_install_keyboard(); al_register_event_source(event_queue,al_get_timer_event_source(timer)); al_register_event_source(event_queue,al_get_keyboard_event_source()); al_register_event_source(event_queue,al_get_display_event_source(display)); init_ship(&ship); init_bullet(&bullet); init_commet(&commet); al_start_timer(timer); while(!done) { ALLEGRO_EVENT ev; al_wait_for_event(event_queue,&ev); if(ev.type == ALLEGRO_EVENT_TIMER) { if(keys[KEY_UP]) { move_ship_up(&ship); } if(keys[KEY_DOWN]) { move_ship_down(&ship); }if(keys[KEY_LEFT]) { move_ship_left(&ship); } if(keys[KEY_RIGHT]) { move_ship_right(&ship); } if(keys[KEY_SPACEBAR]) { fire_bullet(&bullet,&ship); } if(!GameOver) { update_bullet(&bullet); update_commet(&commet); bullet_collision(&bullet,&commet); } redraw = true; } else if(ev.type==ALLEGRO_EVENT_DISPLAY_CLOSE) { done = true; } else if(ev.type == ALLEGRO_EVENT_KEY_DOWN) { switch(ev.keyboard.keycode) { case ALLEGRO_KEY_UP: { keys[KEY_UP]=true; break; } case ALLEGRO_KEY_DOWN: { keys[KEY_DOWN]=true; break; } case ALLEGRO_KEY_LEFT: { keys[KEY_LEFT]=true; break; } case ALLEGRO_KEY_RIGHT : { keys[KEY_RIGHT]=true; break; } case ALLEGRO_KEY_SPACE: { keys[KEY_SPACEBAR] = true; break; } } } else if(ev.type == ALLEGRO_EVENT_KEY_UP) { switch(ev.keyboard.keycode) { case ALLEGRO_KEY_UP: { keys[KEY_UP]=false; break; } case ALLEGRO_KEY_DOWN: { keys[KEY_DOWN]=false; break; } case ALLEGRO_KEY_LEFT: { keys[KEY_LEFT]=false; break; } case ALLEGRO_KEY_RIGHT : { keys[KEY_RIGHT]=false; break; } case ALLEGRO_KEY_SPACE: { keys[KEY_SPACEBAR]=false; break; } } } if(redraw && al_event_queue_is_empty(event_queue)) { redraw = false ; al_clear_to_color(al_map_rgb(255,100,100)); draw_ship(&ship); draw_bullet(bullet); draw_commet(commet); al_flip_display(); al_clear_to_color(al_map_rgb(255,100,100)); } } al_destroy_display(display); al_destroy_timer(timer); al_destroy_event_queue(event_queue); return 0; }
void bullet_update(struct moag *m, int id) { struct bullet *b = &m->bullets[id]; if (!b->active) return; if (b->type == LADDER) { b->active--; b->obj.pos = VEC2_ADD(b->obj.pos, b->obj.vel); b->x = (int)b->obj.pos.x; b->y = (int)b->obj.pos.y; if (get_land_at(m, b->x, b->y) == 1) { explode(m, b->x, b->y + LADDER_LENGTH - b->active, 1, E_SAFE_EXPLODE); bullet_detonate(m, id); } return; } b->obj.pos = VEC2_ADD(b->obj.pos, b->obj.vel); b->obj.vel = VEC2_ADD(b->obj.vel, VEC2(0, GRAVITY)); b->x = (int)b->obj.pos.x; b->y = (int)b->obj.pos.y; if (get_land_at(m, b->x, b->y)) { bullet_detonate(m, id); return; } if (b->active > 1) { b->active--; return; } if (b->type == BOUNCER && b->active == 1) b->active = -BOUNCER_BOUNCES; if (b->type == TUNNELER && b->active == 1) b->active = -TUNNELER_TUNNELINGS; for (int i = 0; i < MAX_PLAYERS; i++) { if(DIST(m->players[i].tank.x, m->players[i].tank.y - 3, b->x, b->y) < 8.5) { bullet_detonate(m, id); return; } } if (m->crate.active && DIST(m->crate.x, m->crate.y - 4, b->x, b->y) < 5.5) { if (m->crate.type == TRIPLER) { float angle = -RAD2DEG(atan2(b->obj.vel.y, b->obj.vel.x)); float speed = VEC2_MAG(b->obj.vel); fire_bullet_ang(m, b->type, b->x, b->y, angle - 20.0, speed); fire_bullet_ang(m, b->type, b->x, b->y, angle + 20.0, speed); } else if (m->crate.type == SHOTGUN) { bullet_detonate(m, id); float angle = -RAD2DEG(atan2(b->obj.vel.y, b->obj.vel.x)); float speed = VEC2_MAG(b->obj.vel); int shots = SHOTGUN_PELLETS; for (int i = 0; i < shots; i++) fire_bullet_ang(m, m->crate.type, m->crate.x, m->crate.y - 4, angle - (shots-1)*2 + i*4, speed*0.5); } else { bullet_detonate(m, id); fire_bullet(m, m->crate.type, m->crate.x, m->crate.y - 4, m->crate.type != BOUNCER ? 0 : b->obj.vel.x < 0 ? -0.2 : 0.2, -0.2); } m->crate.active = false; return; } if (b->type == MIRV && b->obj.vel.y > 0) { bullet_detonate(m, id); return; } if (b->active) broadcast_bullet_chunk(m, MOVE, id); }
void bullet_detonate(struct moag *m, int id) { struct bullet *b = &m->bullets[id]; float d = VEC2_MAG(b->obj.vel); if (d < 0.001 && d >- 0.001) d = d < 0 ? -1 : 1; const float dx = b->obj.vel.x / d; const float dy = b->obj.vel.y / d; float hitx = b->obj.pos.x; float hity = b->obj.pos.y; for (int i = 40; i > 0 && get_land_at(m, (int)hitx, (int)hity); i--) { hitx -= dx; hity -= dy; } switch (b->type) { case MISSILE: explode(m, b->x, b->y, 12, E_EXPLODE); break; case SHOTGUN: explode(m, b->x, b->y, 6, E_EXPLODE); break; case BABY_NUKE: explode(m, b->x, b->y, 55, E_EXPLODE); break; case NUKE: explode(m, b->x, b->y, 150, E_EXPLODE); break; case DIRT: explode(m, b->x, b->y, 55, E_DIRT); break; case SUPER_DIRT: explode(m, b->x, b->y, 300, E_DIRT); break; case COLLAPSE: explode(m, b->x, b->y, 120, E_COLLAPSE); break; case LIQUID_DIRT: for (int i = 0; i < 4; i++) set_timer(m, m->frame + 65*i, LIQUID_DIRT_WARHEAD, b->x, b->y, 0, 0); break; case LIQUID_DIRT_WARHEAD: liquid(m, (int)hitx, (int)hity, 2000); break; case BOUNCER: if (b->active > 0) b->active = -BOUNCER_BOUNCES; b->active++; bounce_bullet(m, id, hitx, hity); b->obj.vel = VEC2_MUL_CONST(b->obj.vel, 0.9); explode(m, b->x, b->y, 12, E_EXPLODE); break; case TUNNELER: if (b->active > 0) b->active = -TUNNELER_TUNNELINGS; b->active++; explode(m, hitx, hity, 9, E_EXPLODE); explode(m, hitx + 8 * dx, hity + 8 * dy, 9, E_EXPLODE); break; case LADDER: { int x = b->x; int y = b->y; for (; y < LAND_HEIGHT; y++) if (get_land_at(m, x, y) == 0) break; for (; y < LAND_HEIGHT; y++) if (get_land_at(m, x, y)) break; const int maxy = y + 1; y = b->y; for (; y > 0; y--) if (get_land_at(m, x, y) == 0) break; const int miny = y; for(; y < maxy; y += 2) { set_land_at(m, x - 1, y, 0); set_land_at(m, x , y, 1); set_land_at(m, x + 1, y, 0); set_land_at(m, x - 1, y + 1, 1); set_land_at(m, x , y + 1, 1); set_land_at(m, x + 1, y + 1, 1); } broadcast_packed_land_chunk(m, x - 1, miny, 3, maxy - miny + 1); break; } case MIRV: bounce_bullet(m, id, hitx, hity); explode(m, b->x, b->y, 12, E_EXPLODE); for (int i = -3; i < 4; i++) fire_bullet(m, MIRV_WARHEAD, b->x, b->y, b->obj.vel.x + i, b->obj.vel.y); break; case MIRV_WARHEAD: explode(m, b->x, b->y, 30, E_EXPLODE); break; case CLUSTER_BOMB: bounce_bullet(m, id, hitx, hity); explode(m, b->x, b->y, 20, E_EXPLODE); for (int i = 0; i < 11; i++) fire_bullet(m, MISSILE, hitx, hity, 2.0 * cosf(i * M_PI / 5.5) + 0.50 * b->obj.vel.x, 2.0 * sinf(i * M_PI / 5.5) + 0.50 * b->obj.vel.y); break; case CLUSTER_BOUNCER: bounce_bullet(m, id, hitx, hity); explode(m, b->x, b->y, 20, E_EXPLODE); for (int i = 0; i < 11; i++) fire_bullet(m, BOUNCER, hitx, hity, 2.0 * cosf(i * M_PI / 5.5) + 0.50 * b->obj.vel.x, 2.0 * sinf(i * M_PI / 5.5) + 0.50 * b->obj.vel.y); break; default: break; } if (b->active >= 0) { b->active = 0; broadcast_bullet_chunk(m, KILL, id); } }
void minisentry_attack (edict_t *self) { int speed, dmg_radius; float chance; vec3_t forward, start, aim; qboolean slowed=false; minisentry_lockon(self); if (self->light_level < 1) return; // out of ammo // are we affected by holy freeze? //if (HasActiveCurse(self, AURA_HOLYFREEZE)) if (que_typeexists(self->curses, AURA_HOLYFREEZE)) slowed = true; // calculate muzzle location AngleVectors(self->s.angles, forward, NULL, NULL); VectorCopy(self->s.origin, start); if (self->owner && self->owner->style == SENTRY_FLIPPED) start[2] -= abs(self->mins[2]); else start[2] += self->maxs[2]; VectorMA(start, (self->maxs[0] + 16), forward, start); if ((level.time > self->wait) && infov(self, self->enemy, 30)) { speed = 650 + 35*self->creator->myskills.abilities[BUILD_SENTRY].current_level; MonsterAim(self, -1, speed, true, 0, aim, start); dmg_radius = self->radius_dmg; if (dmg_radius > 150) dmg_radius = 150; fire_rocket (self, start, aim, self->radius_dmg, speed, dmg_radius, self->radius_dmg); if (slowed) self->wait = level.time + 2.0; else if (self->chill_time > level.time) self->wait = level.time + (1.0 * (1 + CHILL_DEFAULT_BASE + CHILL_DEFAULT_ADDON * self->chill_level)); else self->wait = level.time + 1.0; } self->light_level--; // decrease ammo if (slowed && !(level.framenum%2)) return; // chill effect reduces attack rate/refire if (self->chill_time > level.time) { chance = 1 / (1 + CHILL_DEFAULT_BASE + CHILL_DEFAULT_ADDON * self->chill_level); if (random() > chance) return; } fire_bullet (self, start, forward, self->dmg, 2*self->dmg, DEFAULT_BULLET_HSPREAD, DEFAULT_BULLET_VSPREAD, MOD_SENTRY); gi.sound(self, CHAN_WEAPON, gi.soundindex("weapons/plaser.wav"), 1, ATTN_NORM, 0); gi.WriteByte (svc_muzzleflash); gi.WriteShort (self-g_edicts); gi.WriteByte (MZ_IONRIPPER|MZ_SILENCED); gi.multicast (start, MULTICAST_PVS); }
void Machinegun_Fire (edict_t *ent) { int i; vec3_t start; vec3_t forward, right; vec3_t angles; int damage = 8; int kick = 2; vec3_t offset; if (!(ent->client->buttons & BUTTON_ATTACK)) { ent->client->machinegun_shots = 0; ent->client->ps.gunframe++; return; } if (ent->client->ps.gunframe == 5) ent->client->ps.gunframe = 4; else ent->client->ps.gunframe = 5; if (ent->client->pers.inventory[ent->client->ammo_index] < 1) { ent->client->ps.gunframe = 6; if (level.time >= ent->pain_debounce_time) { gi.sound(ent, CHAN_VOICE, gi.soundindex("weapons/noammo.wav"), 1, ATTN_NORM, 0); ent->pain_debounce_time = level.time + 1; } NoAmmoWeaponChange (ent); return; } if (is_quad) { damage *= 4; kick *= 4; } for (i=1 ; i<3 ; i++) { ent->client->kick_origin[i] = crandom() * 0.35; ent->client->kick_angles[i] = crandom() * 0.7; } ent->client->kick_origin[0] = crandom() * 0.35; ent->client->kick_angles[0] = ent->client->machinegun_shots * -1.5; // raise the gun as it is firing if (!deathmatch->value) { ent->client->machinegun_shots++; if (ent->client->machinegun_shots > 9) ent->client->machinegun_shots = 9; } // get start / end positions VectorAdd (ent->client->v_angle, ent->client->kick_angles, angles); AngleVectors (angles, forward, right, NULL); VectorSet(offset, 0, 8, ent->viewheight-8); P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start); fire_bullet (ent, start, forward, damage, kick, DEFAULT_BULLET_HSPREAD, DEFAULT_BULLET_VSPREAD, MOD_MACHINEGUN); gi.WriteByte (svc_muzzleflash); gi.WriteShort (ent-g_edicts); gi.WriteByte (MZ_MACHINEGUN | is_silenced); gi.multicast (ent->s.origin, MULTICAST_PVS); PlayerNoise(ent, start, PNOISE_WEAPON); if (! ( (int)dmflags->value & DF_INFINITE_AMMO ) ) ent->client->pers.inventory[ent->client->ammo_index]--; ent->client->anim_priority = ANIM_ATTACK; if (ent->client->ps.pmove.pm_flags & PMF_DUCKED) { ent->s.frame = FRAME_crattak1 - (int) (random()+0.25); ent->client->anim_end = FRAME_crattak9; } else { ent->s.frame = FRAME_attack1 - (int) (random()+0.25); ent->client->anim_end = FRAME_attack8; } }
/* updates the player position */ int update_player() { poll_input(); /* quit game? */ if (key[ALLEGRO_KEY_ESCAPE]) return -1; /* safe period while initing */ if (init_time) init_time--; /* blown up? */ if (die_time) { die_time--; if (!die_time) { lives--; if (!lives) return 1; init_time = 128; pos = 0.5; vel = 0; if (lives == 1) message("This Is Your Final Life"); else message("One Life Remaining"); } } /* handle user left/right input */ if (!die_time) { if ((joy_left) || (key[ALLEGRO_KEY_LEFT])) vel -= 0.005; if ((joy_right) || (key[ALLEGRO_KEY_RIGHT])) vel += 0.005; } /* move left and right */ pos += vel; if (pos >= 1.0) pos -= 1.0; if (pos < 0.0) pos += 1.0; vel *= 0.67; /* fire bullets */ if ((!die_time) && (!init_time) && (!fire_time)) { if ((key[ALLEGRO_KEY_SPACE]) || (joy_b1)) { fire_bullet(); fire_time = 24; } } if (fire_time) fire_time--; return 0; }