void Game::zombie_generator(vector <Zombie> &tab_z, Vector2f poz, Texture &tekstura_z, int runda, Vector2f target)
{
Zombie zombie(poz.x, poz.y, tekstura_z, 80, rand() % (runda) + 1, target);
tab_z.push_back(zombie);
}
//Recebe um numero identificador e numero de tickets que é utilizado na chamada fork
int forkTest(int priority,int rodadas){
int pid;
switch (priority) {
case 1:
pid = forkLowest();
break;
case 2:
pid = forkLow();
break;
case 3:
pid = forkMedium();
break;
case 4:
pid = forkHigh();
break;
case 5:
pid = forkHighest();
break;
}
if (pid == 0)
{
// processo filho
zombie(priority,rodadas);
}
else if (pid > 0)
{
// processo pai
//zombie(i);
}
else
{
// falha no fork
printf(1, "fork(1) failed!\n");
return 1;
}
return 0;
}
void Event_Generator()
{
int i,j,con_phone=0;
static int Zobtt=0;
if(player.health==1)
{
printf("You are feeling a little dizzy.\n");
}
for(i=0;i<Max_carries;i++)
{
if(player.inventory[i]==Obj_phone)
con_phone=1;
}
if(_find(Obj_phone))
con_phone=1;
if(condition[Condi_Alarm]&&con_phone)
printf("The alarm of the phone on you is going off.\n");
if(_find(uObj_zombie)&&player.health==0)
{
printf("The zombie is comming at you.\n");
zombie();
}
if(!condition[Condi_Oldman])
{
condition[Condi_Oldman]=1;
Zobtt=step-1;
}
if((step-Zobtt)==5)
{
for(i=0;i<Max_carries;i++)
{
if(player.inventory[i]==Obj_body)
break;
}
if(i<Max_carries)
{
player.inventory[i]=o_n;
//unfinished.
_put(uObj_zombie,-1);
printf("The body seems to start moving.\nYou dropped it on the floor.You soon realize,IT A ZOMBIE!!!!!\n");
}
else
{
for(i=0;i<Map_num_rows;i++)
{
for(j=0;j<Map_num_columns;j++)
{
if(_mfind(i,j,Obj_body))
{
_mpick(i,j,Obj_body);
//unfinished.
_mput(i,j,uObj_zombie);
if(_find(uObj_zombie))
printf("The body seems to start moving.\nYou soon realize,IT A ZOMBIE!!!!!\n");
}
}
}
}
}
}
void ZombieGame::init() {
keyboard_ = DevicePtr(new InputKeyboard(SDLK_UP, SDLK_DOWN, SDLK_LEFT,
SDLK_RIGHT, SDLK_SPACE, SDLK_r, SDLK_LSHIFT, SDLK_e));
clipsize_ = 0;
bulletsInWeapon_ = 0;
health_ = 0;
scale_ = 1.f;
lastSpawnTime_ = engine_.getTime();
spawnPeriod_ = 0.5f;
addKeyListener([&](gui::Component& component, const SDL_Event& keyEvent) {
keyboard_->eventUpdate(keyEvent);
});
if (zombieEntry_.getDeepChildEntry("music switch").getBool()) {
music_ = zombieEntry_.getDeepChildEntry("music track").getMusic();
music_.setVolume(zombieEntry_.getDeepChildEntry("music volume").getFloat());
music_.play(-1);
}
tree_ = zombieEntry_.getDeepChildEntry("tree image").getSprite();
wall_ = zombieEntry_.getDeepChildEntry("buildings wallImage").getSprite();
nbrUnits_ = 0;
unitMaxLimit_ = zombieEntry_.getDeepChildEntry("settings unitLimit").getInt();
innerSpawnRadius_ = zombieEntry_.getDeepChildEntry("settings innerSpawnRadius").getFloat();
outerSpawnRadius_ = zombieEntry_.getDeepChildEntry("settings outerSpawnRadius").getFloat();
terrain_.loadRoadSprites(zombieEntry_.getDeepChildEntry("roads"));
loadTerrain();
explosionProperties_ = zombie::loadExplosion(zombieEntry_.getDeepChildEntry("explosion"));
humanInjured_ = zombieEntry_.getDeepChildEntry("human injuredAnimation").getAnimation();
humanDie_ = zombieEntry_.getDeepChildEntry("human dieAnimation").getAnimation();
Unit2D human(loadUnit(this, "human", zombieEntry_, false));
human.setDieSound(zombieEntry_.getDeepChildEntry("human dieSound").getSound());
human.setHitSound(zombieEntry_.getDeepChildEntry("human hitSound").getSound());
zombieInjured_ = zombieEntry_.getDeepChildEntry("zombie injuredAnimation").getAnimation();
zombieDie_ = zombieEntry_.getDeepChildEntry("zombie dieAnimation").getAnimation();
Unit2D zombie(loadUnit(this, "zombie", zombieEntry_, true));
zombie.setDieSound(zombieEntry_.getDeepChildEntry("zombie dieSound").getSound());
zombie.setHitSound(zombieEntry_.getDeepChildEntry("zombie hitSound").getSound());
// Add human to engine.
{
State state(Position(85,120), ORIGO, 0);
//Position p = generatePosition(spawningPoints_);
//State state(Position(200,200), ORIGO, 0);
Unit* unit = units_.pushBack(human);
engine_.add(unit);
unit->setState(state);
unit->setActive(true);
unit->setAwake(true);
players_.push_back(std::unique_ptr<HumanPlayer>(new HumanPlayer(keyboard_, unit)));
viewPosition_ = state.position_;
refViewPosition_ = viewPosition_;
++nbrUnits_;
}
// Add zombies to engine.
calculateValidSpawningPoints(units_[0]);
unsigned int unitLevel = zombieEntry_.getDeepChildEntry("settings unitLevel").getInt();
for (unsigned int i = 1; i <= unitLevel && i < units_.getMaxSize(); ++i) {
Position p = generatePosition(vaildSpawningPoints_);
float angle = calculateAnglePointToPoint(p, units_[0].getPosition());
State state(p, ORIGO, angle);
Unit* unit = units_.pushBack(zombie);
engine_.add(unit);
unit->setState(state);
unit->setActive(true);
unit->setAwake(true);
players_.push_back(std::unique_ptr<ZombieBehavior>(new ZombieBehavior(unit)));
}
// Add cars to engine.
Car2D car(zombie::loadCar(zombieEntry_.getDeepChildEntry("car")));
for (unsigned int i = 0; i < 8 && i < units_.getMaxSize(); ++i) {
State state(Position(85,130), ORIGO, 0);
Car* c = cars_.pushBack(car);
engine_.add(c);
c->setState(state);
c->setActive(true);
c->setAwake(true);
}
// Add missile to engine.
Missile2D missile(loadMissile2D(this, zombieEntry_.getDeepChildEntry("equipment missile")));
for (unsigned int i = 0; i < 10 && i < units_.getMaxSize(); ++i) {
engine_.add(missiles_.emplaceBack(missile));
}
setBackgroundColor(0, 0.1f, 0);
zombiesKilled_ = 0;
drawBuildings_.createVBO(buildings_, wall_.getTexture());
}
// TODO: Shunt redundant drawing code elsewhere
std::vector<point> game::target(int &x, int &y, int lowx, int lowy, int hix,
int hiy, std::vector <monster> t, int &target,
item *relevent)
{
std::vector<point> ret;
int tarx, tary, junk, tart;
int range=(hix-u.posx);
// First, decide on a target among the monsters, if there are any in range
if (!t.empty()) {
// Check for previous target
if (target == -1) {
// If no previous target, target the closest there is
double closest = -1;
double dist;
for (int i = 0; i < t.size(); i++) {
dist = rl_dist(t[i].posx(), t[i].posy(), u.posx, u.posy);
if (closest < 0 || dist < closest) {
closest = dist;
target = i;
}
}
}
x = t[target].posx();
y = t[target].posy();
} else
target = -1; // No monsters in range, don't use target, reset to -1
bool sideStyle = use_narrow_sidebar();
int height = 13;
int width = getmaxx(w_messages);
int top = sideStyle ? getbegy(w_messages) : (getbegy(w_minimap) + getmaxy(w_minimap));
int left = getbegx(w_messages);
WINDOW* w_target = newwin(height, width, top, left);
draw_border(w_target);
mvwprintz(w_target, 0, 2, c_white, "< ");
if (!relevent) { // currently targetting vehicle to refill with fuel
wprintz(w_target, c_red, _("Select a vehicle"));
} else {
if (relevent == &u.weapon && relevent->is_gun()) {
wprintz(w_target, c_red, _("Firing %s (%d)"), // - %s (%d)",
u.weapon.tname().c_str(),// u.weapon.curammo->name.c_str(),
u.weapon.charges);
} else {
wprintz(w_target, c_red, _("Throwing %s"), relevent->tname().c_str());
}
}
wprintz(w_target, c_white, " >");
/* Annoying clutter @ 2 3 4. */
int text_y = getmaxy(w_target) - 4;
if (is_mouse_enabled()) {
--text_y;
}
mvwprintz(w_target, text_y++, 1, c_white,
_("Move cursor to target with directional keys"));
if (relevent) {
mvwprintz(w_target, text_y++, 1, c_white,
_("'<' '>' Cycle targets; 'f' or '.' to fire"));
mvwprintz(w_target, text_y++, 1, c_white,
_("'0' target self; '*' toggle snap-to-target"));
}
if (is_mouse_enabled()) {
mvwprintz(w_target, text_y++, 1, c_white,
_("Mouse: LMB: Target, Wheel: Cycle, RMB: Fire"));
}
wrefresh(w_target);
bool snap_to_target = OPTIONS["SNAP_TO_TARGET"];
do {
if (m.sees(u.posx, u.posy, x, y, -1, tart))
ret = line_to(u.posx, u.posy, x, y, tart);
else
ret = line_to(u.posx, u.posy, x, y, 0);
if(trigdist && trig_dist(u.posx,u.posy, x,y) > range) {
bool cont=true;
int cx=x;
int cy=y;
for (int i = 0; i < ret.size() && cont; i++) {
if(trig_dist(u.posx,u.posy, ret[i].x, ret[i].y) > range) {
ret.resize(i);
cont=false;
} else {
cx=0+ret[i].x; cy=0+ret[i].y;
}
}
x=cx;y=cy;
}
point center;
if (snap_to_target)
center = point(x, y);
else
center = point(u.posx + u.view_offset_x, u.posy + u.view_offset_y);
// Clear the target window.
for (int i = 1; i < getmaxy(w_target) - 5; i++) {
for (int j = 1; j < getmaxx(w_target) - 2; j++)
mvwputch(w_target, i, j, c_white, ' ');
}
/* Start drawing w_terrain things -- possibly move out to centralized draw_terrain_window function as they all should be roughly similar*/
m.build_map_cache(); // part of the SDLTILES drawing code
m.draw(w_terrain, center); // embedded in SDL drawing code
// Draw the Monsters
for (int i = 0; i < num_zombies(); i++) {
if (u_see(&(zombie(i)))) {
zombie(i).draw(w_terrain, center.x, center.y, false);
}
}
// Draw the NPCs
for (int i = 0; i < active_npc.size(); i++) {
if (u_see(active_npc[i]->posx, active_npc[i]->posy))
active_npc[i]->draw(w_terrain, center.x, center.y, false);
}
if (x != u.posx || y != u.posy) {
// Draw the player
int atx = POSX + u.posx - center.x, aty = POSY + u.posy - center.y;
if (atx >= 0 && atx < TERRAIN_WINDOW_WIDTH && aty >= 0 && aty < TERRAIN_WINDOW_HEIGHT)
mvwputch(w_terrain, aty, atx, u.color(), '@');
// Only draw a highlighted trajectory if we can see the endpoint.
// Provides feedback to the player, and avoids leaking information about tiles they can't see.
draw_line(x, y, center, ret);
/*
if (u_see( x, y)) {
for (int i = 0; i < ret.size(); i++) {
int mondex = mon_at(ret[i].x, ret[i].y),
npcdex = npc_at(ret[i].x, ret[i].y);
// NPCs and monsters get drawn with inverted colors
if (mondex != -1 && u_see(&(zombie(mondex))))
zombie(mondex).draw(w_terrain, center.x, center.y, true);
else if (npcdex != -1)
active_npc[npcdex]->draw(w_terrain, center.x, center.y, true);
else
m.drawsq(w_terrain, u, ret[i].x, ret[i].y, true,true,center.x, center.y);
}
}
//*/
// Print to target window
if (!relevent) {
// currently targetting vehicle to refill with fuel
vehicle *veh = m.veh_at(x, y);
if (veh) {
mvwprintw(w_target, 1, 1, _("There is a %s"),
veh->name.c_str());
}
} else if (relevent == &u.weapon && relevent->is_gun()) {
// firing a gun
mvwprintw(w_target, 1, 1, _("Range: %d"),
rl_dist(u.posx, u.posy, x, y));
// get the current weapon mode or mods
std::string mode = "";
if (u.weapon.mode == "MODE_BURST") {
mode = _("Burst");
} else {
item* gunmod = u.weapon.active_gunmod();
if (gunmod != NULL) {
mode = gunmod->type->name;
}
}
if (mode != "") {
mvwprintw(w_target, 1, 14, _("Firing mode: %s"),
mode.c_str());
}
} else {
// throwing something
mvwprintw(w_target, 1, 1, _("Range: %d"),
rl_dist(u.posx, u.posy, x, y));
}
const int zid = mon_at(x, y);
if (zid == -1) {
if (snap_to_target)
mvwputch(w_terrain, POSY, POSX, c_red, '*');
else
mvwputch(w_terrain, POSY + y - center.y, POSX + x - center.x, c_red, '*');
} else {
if (u_see(&(zombie(zid)))) {
zombie(zid).print_info(w_target,2);
}
}
}
wrefresh(w_target);
wrefresh(w_terrain);
wrefresh(w_status);
refresh();
input_context ctxt("TARGET");
// "ANY_INPUT" should be added before any real help strings
// Or strings will be writen on window border.
ctxt.register_action("ANY_INPUT");
ctxt.register_directions();
ctxt.register_action("COORDINATE");
ctxt.register_action("SELECT");
ctxt.register_action("FIRE");
ctxt.register_action("NEXT_TARGET");
ctxt.register_action("PREV_TARGET");
ctxt.register_action("WAIT");
ctxt.register_action("CENTER");
ctxt.register_action("TOGGLE_SNAP_TO_TARGET");
ctxt.register_action("HELP_KEYBINDINGS");
ctxt.register_action("QUIT");
const std::string& action = ctxt.handle_input();
tarx = 0; tary = 0;
// Our coordinates will either be determined by coordinate input(mouse),
// by a direction key, or by the previous value.
if (action == "SELECT" && ctxt.get_coordinates(g->w_terrain, tarx, tary)) {
if (!OPTIONS["USE_TILES"] && snap_to_target) {
// Snap to target doesn't currently work with tiles.
tarx += x - u.posx;
tary += y - u.posy;
}
tarx -= x;
tary -= y;
} else {
ctxt.get_direction(tarx, tary, action);
if(tarx == -2) {
tarx = 0;
tary = 0;
}
}
/* More drawing to terrain */
if (tarx != 0 || tary != 0) {
int mondex = mon_at(x, y), npcdex = npc_at(x, y);
if (mondex != -1 && u_see(&(zombie(mondex))))
zombie(mondex).draw(w_terrain, center.x, center.y, false);
else if (npcdex != -1)
active_npc[npcdex]->draw(w_terrain, center.x, center.y, false);
else if (m.sees(u.posx, u.posy, x, y, -1, junk))
m.drawsq(w_terrain, u, x, y, false, true, center.x, center.y);
else
mvwputch(w_terrain, POSY, POSX, c_black, 'X');
x += tarx;
y += tary;
if (x < lowx)
x = lowx;
else if (x > hix)
x = hix;
if (y < lowy)
y = lowy;
else if (y > hiy)
y = hiy;
} else if ((action == "PREV_TARGET") && (target != -1)) {
target--;
if (target == -1) target = t.size() - 1;
x = t[target].posx();
y = t[target].posy();
} else if ((action == "NEXT_TARGET") && (target != -1)) {
target++;
if (target == t.size()) target = 0;
x = t[target].posx();
y = t[target].posy();
} else if (action == "WAIT" || action == "FIRE") {
for (int i = 0; i < t.size(); i++) {
if (t[i].posx() == x && t[i].posy() == y)
target = i;
}
if (u.posx == x && u.posy == y)
ret.clear();
break;
} else if (action == "CENTER") {
x = u.posx;
y = u.posy;
ret.clear();
} else if (action == "TOGGLE_SNAP_TO_TARGET")
snap_to_target = !snap_to_target;
else if (action == "QUIT") { // return empty vector (cancel)
ret.clear();
break;
}
} while (true);
return ret;
}
void game::throw_item(player &p, int tarx, int tary, item &thrown,
std::vector<point> &trajectory)
{
int deviation = 0;
int trange = 1.5 * rl_dist(p.posx, p.posy, tarx, tary);
std::set<std::string> no_effects;
// Throwing attempts below "Basic Competency" level are extra-bad
int skillLevel = p.skillLevel("throw");
if (skillLevel < 3) {
deviation += rng(0, 8 - skillLevel);
}
if (skillLevel < 8) {
deviation += rng(0, 8 - skillLevel);
} else {
deviation -= skillLevel - 6;
}
deviation += p.throw_dex_mod();
if (p.per_cur < 6) {
deviation += rng(0, 8 - p.per_cur);
} else if (p.per_cur > 8) {
deviation -= p.per_cur - 8;
}
deviation += rng(0, p.encumb(bp_hands) * 2 + p.encumb(bp_eyes) + 1);
if (thrown.volume() > 5) {
deviation += rng(0, 1 + (thrown.volume() - 5) / 4);
}
if (thrown.volume() == 0) {
deviation += rng(0, 3);
}
deviation += rng(0, std::max( 0, p.str_cur - thrown.weight() / 113 ) );
double missed_by = .01 * deviation * trange;
bool missed = false;
int tart;
if (missed_by >= 1) {
// We missed D:
// Shoot a random nearby space?
if (missed_by > 9) {
missed_by = 9;
}
tarx += rng(0 - int(sqrt(double(missed_by))), int(sqrt(double(missed_by))));
tary += rng(0 - int(sqrt(double(missed_by))), int(sqrt(double(missed_by))));
if (m.sees(p.posx, p.posy, tarx, tary, -1, tart)) {
trajectory = line_to(p.posx, p.posy, tarx, tary, tart);
} else {
trajectory = line_to(p.posx, p.posy, tarx, tary, 0);
}
missed = true;
add_msg_if_player(&p,_("You miss!"));
} else if (missed_by >= .6) {
// Hit the space, but not necessarily the monster there
missed = true;
add_msg_if_player(&p,_("You barely miss!"));
}
std::string message;
int real_dam = (thrown.weight() / 452 + thrown.type->melee_dam / 2 + p.str_cur / 2) /
double(2 + double(thrown.volume() / 4));
if (real_dam > thrown.weight() / 40) {
real_dam = thrown.weight() / 40;
}
if (p.has_active_bionic("bio_railgun") && (thrown.made_of("iron") || thrown.made_of("steel"))) {
real_dam *= 2;
}
int dam = real_dam;
int i = 0, tx = 0, ty = 0;
for (i = 0; i < trajectory.size() && dam >= 0; i++) {
message = "";
double goodhit = missed_by;
tx = trajectory[i].x;
ty = trajectory[i].y;
const int zid = mon_at(tx, ty);
// If there's a monster in the path of our item, and either our aim was true,
// OR it's not the monster we were aiming at and we were lucky enough to hit it
if (zid != -1 && (!missed || one_in(7 - int(zombie(zid).type->size)))) {
monster &z = zombie(zid);
if (rng(0, 100) < 20 + skillLevel * 12 && thrown.type->melee_cut > 0) {
if (!p.is_npc()) {
message += string_format(_(" You cut the %s!"), z.name().c_str());
}
if (thrown.type->melee_cut > z.get_armor_cut(bp_torso)) {
dam += (thrown.type->melee_cut - z.get_armor_cut(bp_torso));
}
}
if (thrown.made_of("glass") && !thrown.active && // active = molotov, etc.
rng(0, thrown.volume() + 8) - rng(0, p.str_cur) < thrown.volume()) {
if (u_see(tx, ty)) {
add_msg(_("The %s shatters!"), thrown.tname().c_str());
}
for (int i = 0; i < thrown.contents.size(); i++) {
m.add_item_or_charges(tx, ty, thrown.contents[i]);
}
sound(tx, ty, 16, _("glass breaking!"));
int glassdam = rng(0, thrown.volume() * 2);
if (glassdam > z.get_armor_cut(bp_torso)) {
dam += (glassdam - z.get_armor_cut(bp_torso));
}
} else {
m.add_item_or_charges(tx, ty, thrown);
}
if (i < trajectory.size() - 1) {
goodhit = double(double(rand() / RAND_MAX) / 2);
}
if (goodhit < .1 && !z.has_flag(MF_NOHEAD)) {
message = _("Headshot!");
dam = rng(dam, dam * 3);
p.practice(turn, "throw", 5);
p.lifetime_stats()->headshots++;
} else if (goodhit < .2) {
message = _("Critical!");
dam = rng(dam, dam * 2);
p.practice(turn, "throw", 2);
} else if (goodhit < .4) {
dam = rng(int(dam / 2), int(dam * 1.5));
} else if (goodhit < .5) {
message = _("Grazing hit.");
dam = rng(0, dam);
}
if (u_see(tx, ty)) {
g->add_msg_player_or_npc(&p,
_("%s You hit the %s for %d damage."),
_("%s <npcname> hits the %s for %d damage."),
message.c_str(), z.name().c_str(), dam);
}
if (z.hurt(dam, real_dam)) {
z.die(&p);
}
return;
} else { // No monster hit, but the terrain might be.
m.shoot(tx, ty, dam, false, no_effects);
}
// Collide with impassable terrain
if (m.move_cost(tx, ty) == 0) {
if (i > 0) {
tx = trajectory[i - 1].x;
ty = trajectory[i - 1].y;
} else {
tx = u.posx;
ty = u.posy;
}
i = trajectory.size();
}
if (p.has_active_bionic("bio_railgun") &&
(thrown.made_of("iron") || thrown.made_of("steel"))) {
m.add_field(tx, ty, fd_electricity, rng(2,3));
}
}
if (thrown.made_of("glass") && !thrown.active && // active means molotov, etc
rng(0, thrown.volume() + 8) - rng(0, p.str_cur) < thrown.volume()) {
if (u_see(tx, ty)) {
add_msg(_("The %s shatters!"), thrown.tname().c_str());
}
for (int i = 0; i < thrown.contents.size(); i++) {
m.add_item_or_charges(tx, ty, thrown.contents[i]);
}
sound(tx, ty, 16, _("glass breaking!"));
} else {
if(m.has_flag("LIQUID", tx, ty)) {
sound(tx, ty, 10, _("splash!"));
} else {
sound(tx, ty, 8, _("thud."));
}
m.add_item_or_charges(tx, ty, thrown);
}
}
