/*
* Updates the space-object to reflect what empire it is currently inside
* announces both inbound and outbound and also when you enter and depart
*/
void up_empire (void)
{
double dx, dy, dz;
int index = 0;
aspace_borders *si = NULL;
for (index = 1; index <= im_count(border_map); index++)
{
si = im_find(border_map, index);
if (si != NULL) {
dx = (si->x - sdb[n].coords.x) / PARSEC;
dy = (si->y - sdb[n].coords.y) / PARSEC;
dz = (si->z - sdb[n].coords.z) / PARSEC;
if ((dx * dx + dy * dy + dz * dz) < (si->radius * si->radius)) {
if (sdb[n].move.empire != index) {
if ((int)get_random_long(0,100) < ((int) (sdb[n].sensor.lrs_signature * sdb[n].sensor.visibility * 100.0))) {
alert_exit_empire(n);
alert_border_cross (n, sdb[n].move.empire, 0);
}
sdb[n].move.empire = index;
if ((int)get_random_long(0,100) < ((int) (sdb[n].sensor.lrs_signature * sdb[n].sensor.visibility * 100.0))) {
alert_enter_empire(n);
alert_border_cross (n, sdb[n].move.empire, 1);
}
}
break;
}
}
}
return;
}
unsigned long arch_mmap_rnd(void)
{
unsigned long rnd;
if (mmap_is_ia32())
#ifdef CONFIG_COMPAT
rnd = get_random_long() & ((1UL << mmap_rnd_compat_bits) - 1);
#else
rnd = get_random_long() & ((1UL << mmap_rnd_bits) - 1);
#endif
else
static unsigned long mmap_rnd(void)
{
unsigned long rnd = 0;
if (current->flags & PF_RANDOMIZE) {
/* 8MB for 32bit, 1GB for 64bit */
if (is_32bit_task())
rnd = get_random_long() % (1UL<<(23-PAGE_SHIFT));
else
rnd = get_random_long() % (1UL<<(30-PAGE_SHIFT));
}
return rnd << PAGE_SHIFT;
}
unsigned long arch_mmap_rnd(void)
{
unsigned long rnd;
#ifdef CONFIG_COMPAT
if (TASK_IS_32BIT_ADDR)
rnd = get_random_long() & ((1UL << mmap_rnd_compat_bits) - 1);
else
#endif /* CONFIG_COMPAT */
rnd = get_random_long() & ((1UL << mmap_rnd_bits) - 1);
return rnd << PAGE_SHIFT;
}
static unsigned long mmap_rnd(void)
{
unsigned long rnd = 0;
if (current->flags & PF_RANDOMIZE) {
if (mmap_is_ia32())
#ifdef CONFIG_COMPAT
rnd = get_random_long() & ((1UL << mmap_rnd_compat_bits) - 1);
#else
rnd = get_random_long() & ((1UL << mmap_rnd_bits) - 1);
#endif
else
rnd = get_random_long() & ((1UL << mmap_rnd_bits) - 1);
}
/*
* Since get_random_int() returns the same value within a 1 jiffy window, we
* will almost always get the same randomisation for the stack and mmap
* region. This will mean the relative distance between stack and mmap will be
* the same.
*
* To avoid this we can shift the randomness by 1 bit.
*/
static unsigned long mmap_rnd(void)
{
unsigned long rnd = 0;
if (current->flags & PF_RANDOMIZE) {
#ifdef CONFIG_COMPAT
if (test_thread_flag(TIF_32BIT))
rnd = get_random_long() & ((1UL << mmap_rnd_compat_bits) - 1);
else
#endif
rnd = get_random_long() & ((1UL << mmap_rnd_bits) - 1);
}
return rnd << (PAGE_SHIFT + 1);
}
static unsigned long mmap_rnd(void)
{
unsigned long rnd = 0;
/*
* 8 bits of randomness in 32bit mmaps, 20 address space bits
* 28 bits of randomness in 64bit mmaps, 40 address space bits
*/
if (current->flags & PF_RANDOMIZE) {
#ifdef CONFIG_COMPAT
rnd = get_random_long() & ((1UL << mmap_rnd_compat_bits) - 1);
#else
rnd = get_random_long() & ((1UL << mmap_rnd_bits) - 1);
#endif
else
static struct task_struct *dup_task_struct(struct task_struct *orig)
{
struct task_struct *tsk;
struct thread_info *ti;
unsigned long *stackend;
int err;
prepare_to_copy(orig);
tsk = alloc_task_struct();
if (!tsk)
return NULL;
ti = alloc_thread_info(tsk);
if (!ti) {
free_task_struct(tsk);
return NULL;
}
err = arch_dup_task_struct(tsk, orig);
if (err)
goto out;
tsk->stack = ti;
err = prop_local_init_single(&tsk->dirties);
if (err)
goto out;
setup_thread_stack(tsk, orig);
stackend = end_of_stack(tsk);
*stackend = STACK_END_MAGIC; /* for overflow detection */
#ifdef CONFIG_CC_STACKPROTECTOR
tsk->stack_canary = get_random_long();
#endif
/* One for us, one for whoever does the "release_task()" (usually parent) */
atomic_set(&tsk->usage,2);
atomic_set(&tsk->fs_excl, 0);
#ifdef CONFIG_BLK_DEV_IO_TRACE
tsk->btrace_seq = 0;
#endif
tsk->splice_pipe = NULL;
account_kernel_stack(ti, 1);
return tsk;
out:
free_thread_info(ti);
free_task_struct(tsk);
return NULL;
}
/* Essentially the same as PowerPC. */
static unsigned long mmap_rnd(void)
{
unsigned long rnd = 0UL;
if (current->flags & PF_RANDOMIZE) {
unsigned long val = get_random_long();
if (test_thread_flag(TIF_32BIT))
rnd = (val % (1UL << (23UL-PAGE_SHIFT)));
else
rnd = (val % (1UL << (30UL-PAGE_SHIFT)));
}
return rnd << PAGE_SHIFT;
}
static inline unsigned long brk_rnd(void)
{
unsigned long rnd = get_random_long();
rnd = rnd << PAGE_SHIFT;
/* 8MB for 32bit, 256MB for 64bit */
if (TASK_IS_32BIT_ADDR)
rnd = rnd & 0x7ffffful;
else
rnd = rnd & 0xffffffful;
return rnd;
}
void arch_pick_mmap_layout(struct mm_struct *mm)
{
unsigned long random_factor = 0UL;
if ((current->flags & PF_RANDOMIZE) &&
!(current->personality & ADDR_NO_RANDOMIZE))
random_factor = (get_random_long() % (1 << mmap_rnd_bits)) << PAGE_SHIFT;
if (mmap_is_legacy()) {
mm->mmap_base = TASK_UNMAPPED_BASE + random_factor;
mm->get_unmapped_area = arch_get_unmapped_area;
mm->unmap_area = arch_unmap_area;
} else {
mm->mmap_base = mmap_base(random_factor);
mm->get_unmapped_area = arch_get_unmapped_area_topdown;
mm->unmap_area = arch_unmap_area_topdown;
}
}
void arch_pick_mmap_layout(struct mm_struct *mm)
{
unsigned long random_factor = 0UL;
if (current->flags & PF_RANDOMIZE) {
random_factor = get_random_long();
random_factor = random_factor << PAGE_SHIFT;
if (TASK_IS_32BIT_ADDR)
random_factor &= 0xfffffful;
else
random_factor &= 0xffffffful;
}
if (mmap_is_legacy()) {
mm->mmap_base = TASK_UNMAPPED_BASE + random_factor;
mm->get_unmapped_area = arch_get_unmapped_area;
} else {
mm->mmap_base = mmap_base(random_factor);
mm->get_unmapped_area = arch_get_unmapped_area_topdown;
}
}
void damage_main (int x, double damage)
{
if (!sdb[x].main.exist || sdb[x].main.damage == -1.0)
return;
if (sdb[x].power.main != 0.0
&& sdb[x].main.damage > 0.0
&& (sdb[x].main.damage - damage / sdb[x].main.gw <= 0.0)) {
alert_main_overload(x);
}
sdb[x].main.damage -= damage / sdb[x].main.gw;
if (sdb[x].main.damage < -1.0) {
sdb[x].main.damage = -1.0;
if (sdb[x].power.main != 0.0) {
do_all_console_notify(x, tprintf(ansi_warn("%s core breach."), system_name[8]));
damage_structure(x, sdb[x].power.main * (get_random_long(0,100) + 1.0));
}
}
do_console_notify(x, console_engineering, console_damage, 0,
ansi_alert(tprintf("%s%s%s: %s %s",
ANSI_CYAN, system_name[8], ANSI_WHITE,
unparse_percent(sdb[x].main.damage),
unparse_damage(sdb[x].main.damage))));
return;
}
return sysctl_legacy_va_layout;
}
unsigned long arch_mmap_rnd(void)
{
unsigned long rnd;
if (mmap_is_ia32())
#ifdef CONFIG_COMPAT
rnd = get_random_long() & ((1UL << mmap_rnd_compat_bits) - 1);
#else
rnd = get_random_long() & ((1UL << mmap_rnd_bits) - 1);
#endif
else
rnd = get_random_long() & ((1UL << mmap_rnd_bits) - 1);
return rnd << PAGE_SHIFT;
}
static unsigned long mmap_base(unsigned long rnd)
{
unsigned long gap = rlimit(RLIMIT_STACK);
if (gap < MIN_GAP)
gap = MIN_GAP;
else if (gap > MAX_GAP)
gap = MAX_GAP;
return PAGE_ALIGN(TASK_SIZE - gap - rnd);
}
int debug_space (int x)
{
register int i, bug = 1;
/* --- OBJECT ------------------------------------------------------------- */
if (sdb[x].structure.type <= 0) {
sdb[x].structure.type = 0;
bug = 0;
}
if (!SpaceObj(sdb[x].object) || !GoodObject(sdb[x].object)) {
sdb[x].object = 0;
sdb[x].structure.type = 0;
bug = 0;
}
/* --- LOCATION ----------------------------------------------------------- */
sdb[x].location = 0;
for (i = MIN_SPACE_OBJECTS ; i <= max_space_objects ; ++i)
if (SpaceObj(sdb[i].object)) {
if (Location(sdb[i].object) == sdb[x].object)
sdb[i].location = x;
if (Location(sdb[x].object) == sdb[i].object)
sdb[x].location = i;
}
/* --- MAIN --------------------------------------------------------------- */
if (!sdb[x].main.exist || sdb[x].main.gw <= 0) {
sdb[x].main.damage = 0.0;
sdb[x].main.exist = 0;
sdb[x].main.gw = 0.0;
sdb[x].main.in = 0.0;
sdb[x].main.out = 0.0;
sdb[x].power.main = 0.0;
}
/* --- AUX ---------------------------------------------------------------- */
if (!sdb[x].aux.exist || sdb[x].aux.gw <= 0) {
sdb[x].aux.damage = 0.0;
sdb[x].aux.exist = 0;
sdb[x].aux.gw = 0.0;
sdb[x].aux.in = 0.0;
sdb[x].aux.out = 0.0;
sdb[x].power.aux = 0.0;
}
/* --- BATT --------------------------------------------------------------- */
if (!sdb[x].batt.exist || sdb[x].batt.gw <= 0) {
sdb[x].batt.damage = 0.0;
sdb[x].batt.exist = 0;
sdb[x].batt.gw = 0.0;
sdb[x].batt.in = 0.0;
sdb[x].batt.out = 0.0;
sdb[x].fuel.reserves = 0.0;
sdb[x].power.batt = 0.0;
}
/* --- ALLOCATE ----------------------------------------------------------- */
if (!sdb[x].main.exist && !sdb[x].aux.exist && !sdb[x].batt.exist) {
sdb[x].alloc.helm = 0.0;
sdb[x].alloc.tactical = 0.0;
sdb[x].alloc.operations = 1.0;
sdb[x].alloc.movement = 0.0;
sdb[x].alloc.shields = 0.0;
for (i = 0 ; i < MAX_SHIELD_NAME ; ++i)
sdb[x].alloc.shield[i] = 0.0;
sdb[x].alloc.cloak = 0.0;
sdb[x].alloc.beams = 0.0;
sdb[x].alloc.missiles = 0.0;
sdb[x].alloc.sensors = 0.0;
sdb[x].alloc.ecm = 0.0;
sdb[x].alloc.eccm = 0.0;
sdb[x].alloc.transporters = 0.0;
sdb[x].alloc.tractors = 0.0;
sdb[x].alloc.miscellaneous = 1.0;
sdb[x].power.total = 0.0;
sdb[x].beam.in = 0.0;
sdb[x].beam.out = 0.0;
sdb[x].missile.in = 0.0;
sdb[x].missile.out = 0.0;
}
/* --- BEAM --------------------------------------------------------------- */
if (!sdb[x].beam.exist || sdb[x].beam.banks <= 0) {
sdb[x].beam.banks = 0;
sdb[x].beam.exist = 0;
sdb[x].beam.freq = 0.0;
sdb[x].beam.in = 0.0;
sdb[x].beam.out = 0.0;
for (i = 0; i < MAX_BEAM_BANKS; ++i) {
sdb[x].blist.name[i] = 0;
sdb[x].blist.damage[i] = 0.0;
sdb[x].blist.bonus[i] = 0;
sdb[x].blist.cost[i] = 0;
sdb[x].blist.range[i] = 0;
sdb[x].blist.arcs[i] = 0;
sdb[x].blist.active[i] = 0;
sdb[x].blist.lock[i] = 0;
sdb[x].blist.load[i] = 0;
sdb[x].blist.recycle[i] = 0;
}
} else {
if (sdb[x].beam.in < 0.0) {
sdb[x].beam.in = 0.0;
bug = 0;
}
if (sdb[x].beam.out < 0.0) {
sdb[x].beam.out = 0.0;
bug = 0;
}
if (sdb[x].beam.banks > MAX_BEAM_BANKS) {
sdb[x].beam.banks = MAX_BEAM_BANKS;
bug = 0;
}
if (sdb[x].beam.freq <= 1.0 || sdb[x].beam.freq >= 1000.0) {
sdb[x].beam.freq = get_random_long(0,10000) / 100.0;
bug = 0;
}
for (i = 0; i < MAX_BEAM_BANKS; ++i) {
if (!(sdb[x].blist.arcs[i] & 1) && !(sdb[x].blist.arcs[i] & 4))
sdb[x].blist.arcs[i] += 5;
if (!(sdb[x].blist.arcs[i] & 2) && !(sdb[x].blist.arcs[i] & 8))
sdb[x].blist.arcs[i] += 10;
if (!(sdb[x].blist.arcs[i] & 16) && !(sdb[x].blist.arcs[i] & 32))
sdb[x].blist.arcs[i] += 48;
}
for (i = 0; i < MAX_BEAM_BANKS; ++i) {
if (sdb[x].blist.recycle[i] < 1) {
sdb[x].blist.recycle[i] = 1;
// Jarek fixed this to not throw bugs for every non-existant weapon
if(i < sdb[x].beam.banks)
bug = 0;
}
}
}
/* --- MISSILE ------------------------------------------------------------ */
if (!sdb[x].missile.exist || sdb[x].missile.tubes <= 0) {
sdb[x].missile.exist = 0;
sdb[x].missile.freq = 0.0;
sdb[x].missile.tubes = 0;
sdb[x].missile.in = 0.0;
sdb[x].missile.out = 0.0;
for (i = 0; i < MAX_MISSILE_TUBES; ++i) {
sdb[x].mlist.name[i] = 0;
sdb[x].mlist.damage[i] = 0.0;
sdb[x].mlist.warhead[i] = 0;
sdb[x].mlist.cost[i] = 0;
sdb[x].mlist.range[i] = 0;
sdb[x].mlist.arcs[i] = 0;
sdb[x].mlist.active[i] = 0;
sdb[x].mlist.lock[i] = 0;
sdb[x].mlist.load[i] = 0;
sdb[x].mlist.recycle[i] = 0;
}
} else {
if (sdb[x].missile.out < 0.0) {
sdb[x].missile.out = 0.0;
bug = 0;
}
if (sdb[x].missile.in < 0.0) {
sdb[x].missile.in = 0.0;
bug = 0;
}
if (sdb[x].missile.tubes > MAX_MISSILE_TUBES) {
sdb[x].missile.tubes = MAX_MISSILE_TUBES;
bug = 0;
}
if (sdb[x].missile.freq <= 1.0 || sdb[x].missile.freq >= 1000.0) {
sdb[x].missile.freq = get_random_long(0,10000) / 100.0;
bug = 0;
}
for (i = 0; i < MAX_MISSILE_TUBES; ++i) {
if (!(sdb[x].mlist.arcs[i] & 1) && !(sdb[x].mlist.arcs[i] & 4))
sdb[x].mlist.arcs[i] += 5;
if (!(sdb[x].mlist.arcs[i] & 2) && !(sdb[x].mlist.arcs[i] & 8))
sdb[x].mlist.arcs[i] += 10;
if (!(sdb[x].mlist.arcs[i] & 16) && !(sdb[x].mlist.arcs[i] & 32))
sdb[x].mlist.arcs[i] += 48;
}
for (i = 0; i < MAX_MISSILE_TUBES; ++i) {
if (sdb[x].mlist.recycle[i] < 1) {
sdb[x].mlist.recycle[i] = 1;
// Jarek fixed this to not throw bugs for every non-existant weapon
if(i < sdb[x].missile.tubes)
bug = 0;
}
}
}
/* --- ENGINE ------------------------------------------------------------- */
if (!sdb[x].engine.impulse_exist) {
sdb[x].engine.impulse_exist = 0;
sdb[x].engine.impulse_damage = 0.0;
sdb[x].engine.impulse_max = 0.0;
sdb[x].engine.impulse_cruise = 0.0;
sdb[x].engine.impulse_hard_cruise = 0.0; /* Anyasha - STDW - Hard Cruise Speed */
}
if (!sdb[x].engine.warp_exist) {
sdb[x].engine.warp_exist = 0;
sdb[x].engine.warp_damage = 0.0;
sdb[x].engine.warp_max = 0.0;
sdb[x].engine.warp_cruise = 0.0;
sdb[x].engine.warp_hard_cruise = 0.0; /* Anyasha - STDW - Hard Cruise Speed */
}
if (!sdb[x].engine.warp_exist && !sdb[x].engine.impulse_exist) {
sdb[x].move.in = 0.0;
sdb[x].move.out = 0.0;
}
/* --- STRUCTURE ---------------------------------------------------------- */
if (sdb[x].structure.displacement <= 0) {
sdb[x].structure.displacement = 1;
bug = 0;
}
if (sdb[x].structure.cargo_hold > sdb[x].structure.displacement) {
sdb[x].structure.cargo_hold = sdb[x].structure.displacement;
bug = 0;
} else if (sdb[x].structure.cargo_hold < 0) {
sdb[x].structure.cargo_hold = 0;
bug = 0;
}
if (sdb[x].structure.max_structure <= 0) {
sdb[x].structure.max_structure = 1;
bug = 0;
}
if (sdb[x].structure.superstructure > sdb[x].structure.max_structure) {
sdb[x].structure.superstructure = sdb[x].structure.max_structure;
bug = 0;
}
if (sdb[x].structure.max_repair < 0) {
sdb[x].structure.max_repair = 0;
bug = 0;
}
if (sdb[x].structure.repair > sdb[x].structure.max_repair) {
sdb[x].structure.repair = sdb[x].structure.max_repair;
bug = 0;
} else if (sdb[x].structure.repair < 0.0) {
sdb[x].structure.repair = 0.0;
bug = 0;
}
/* --- SENSOR ------------------------------------------------------------- */
if (!sdb[x].sensor.lrs_exist) {
sdb[x].sensor.lrs_active = 0;
sdb[x].sensor.lrs_damage = 0.0;
sdb[x].sensor.lrs_resolution = 0.0;
}
if (!sdb[x].sensor.srs_exist) {
sdb[x].sensor.srs_active = 0;
sdb[x].sensor.srs_damage = 0.0;
sdb[x].sensor.srs_resolution = 0.0;
}
if (!sdb[x].sensor.ew_exist) {
sdb[x].sensor.ew_active = 0;
sdb[x].sensor.ew_damage = 0.0;
}
if (!sdb[x].sensor.srs_exist && !sdb[x].sensor.lrs_exist) {
sdb[x].sensor.contacts = 0;
sdb[x].sensor.counter = 0;
for (i = 0 ; i < MAX_SENSOR_CONTACTS ; ++i) {
sdb[x].slist.sdb[i] = 0;
sdb[x].slist.num[i] = 0;
sdb[x].slist.lev[i] = 0.0;
}
}
/* --- SHIELD ------------------------------------------------------------- */
if (!sdb[x].shield.exist || sdb[x].shield.ratio <= 0.0 || sdb[x].shield.maximum <= 0) {
sdb[x].shield.ratio = 0.0;
sdb[x].shield.maximum = 0;
sdb[x].shield.freq = 0.0;
sdb[x].shield.exist = 0;
for (i = 0 ; i < MAX_SHIELD_NAME; ++i) {
sdb[x].shield.damage[i] = 0.0;
sdb[x].shield.active[i] = 0;
sdb[x].shield.capacitor[i] = 0.0; /* line added for shield capacitors - Anya STDW */
}
}
/* --- TECH --------------------------------------------------------------- */
if (sdb[x].tech.firing <= 0.0) {
sdb[x].tech.firing = 1.0;
bug = 0;
}
if (sdb[x].tech.fuel <= 0.0) {
sdb[x].tech.fuel = 1.0;
bug = 0;
}
if (sdb[x].tech.stealth <= 0.0) {
sdb[x].tech.stealth = 1.0;
bug = 0;
}
if (sdb[x].tech.cloak <= 0.0) {
sdb[x].tech.cloak = 1.0;
bug = 0;
}
if (sdb[x].tech.sensors <= 0.0) {
sdb[x].tech.sensors = 1.0;
bug = 0;
}
if (sdb[x].tech.main_max <= 0.0) {
sdb[x].tech.main_max = 1.0;
bug = 0;
}
if (sdb[x].tech.aux_max <= 0.0) {
sdb[x].tech.aux_max = 1.0;
bug = 0;
}
if (sdb[x].tech.armor <= 0.0) {
sdb[x].tech.armor = 1.0;
bug = 0;
}
/* --- MOVE --------------------------------------------------------------- */
if (sdb[x].move.ratio <= 0.0) {
sdb[x].move.ratio = 1.0;
bug = 0;
}
/* --- CLOAK -------------------------------------------------------------- */
if (!sdb[x].cloak.exist || sdb[x].cloak.cost <= 0) {
sdb[x].cloak.cost = 0;
sdb[x].cloak.damage = 0.0;
sdb[x].cloak.exist = 0;
sdb[x].cloak.freq = 0.0;
sdb[x].cloak.active = 0;
} else {
if (sdb[x].cloak.freq <= 1.0 || sdb[x].cloak.freq >= 1000.0) {
sdb[x].cloak.freq = get_random_long(0,10000) / 100.0;
bug = 0;
}
}
/* --- TRANS -------------------------------------------------------------- */
if (!sdb[x].trans.exist) {
sdb[x].trans.cost = 0;
sdb[x].trans.damage = 0;
sdb[x].trans.freq = 0;
sdb[x].trans.active = 0;
sdb[x].trans.d_lock = 0;
sdb[x].trans.s_lock = 0;
} else if (sdb[x].trans.freq <= 1.0 || sdb[x].trans.freq >= 1000.0) {
sdb[x].trans.freq = get_random_long(0,10000) / 100.0;
bug = 0;
}
if (sdb[x].trans.d_lock)
if (sdb[x].trans.d_lock != x)
if (sdb2contact(n, sdb[x].trans.d_lock) == SENSOR_FAIL) {
sdb[x].trans.d_lock = 0;
}
if (sdb[x].trans.s_lock)
if (sdb[x].trans.s_lock != x)
if (sdb2contact(n, sdb[x].trans.s_lock) == SENSOR_FAIL) {
sdb[x].trans.s_lock = 0;
}
/* --- TRACT -------------------------------------------------------------- */
if (!sdb[x].tract.exist) {
sdb[x].tract.cost = 0;
sdb[x].tract.damage = 0;
sdb[x].tract.freq = 0;
sdb[x].tract.active = 0;
sdb[x].tract.lock = 0;
sdb[x].status.tractoring = 0;
} else if (sdb[x].tract.freq <= 1.0 || sdb[x].tract.freq >= 1000.0) {
sdb[x].tract.freq = get_random_long(0,10000) / 100.0;
bug = 0;
}
/* if (sdb[x].status.tractoring)
if (sdb2contact(n, sdb[x].status.tractoring) == SENSOR_FAIL) {
sdb[sdb[x].status.tractoring].status.tractored = 0;
sdb[x].tract.lock = 0;
sdb[x].status.tractoring = 0;
} */
/* if (sdb[x].status.tractored)
if (sdb2contact(sdb[x].status.tractored, x) == SENSOR_FAIL) {
sdb[sdb[x].status.tractored].status.tractoring = 0;
sdb[sdb[x].status.tractored].tract.lock = 0;
sdb[x].status.tractored = 0;
} */
/* --- FUEL --------------------------------------------------------------- */
if (sdb[x].fuel.antimatter < 0.0)
sdb[x].fuel.antimatter = 0.0;
if (sdb[x].fuel.deuterium < 0.0)
sdb[x].fuel.deuterium = 0.0;
if (sdb[x].fuel.reserves < 0.0)
sdb[x].fuel.reserves = 0.0;
if (sdb[x].fuel.antimatter > sdb2max_antimatter(x))
sdb[x].fuel.antimatter = sdb2max_antimatter(x);
if (sdb[x].fuel.deuterium > sdb2max_deuterium(x))
sdb[x].fuel.deuterium = sdb2max_deuterium(x);
if (sdb[x].fuel.reserves > sdb2max_reserve(x))
sdb[x].fuel.reserves = sdb2max_reserve(x);
/* --- STATUS ------------------------------------------------------------- */
if (sdb[x].structure.superstructure <= -sdb[x].structure.max_structure) {
sdb[x].status.crippled = 2;
} else if (sdb[x].structure.superstructure <= 0.0) {
sdb[x].status.crippled = 1;
} else {
sdb[x].status.crippled = 0;
}
/* --- other updates ------------------------------------------------------ */
up_cochranes();
up_turn_rate();
up_vectors();
up_empire();
up_quadrant();
up_resolution();
up_signature(x);
up_visibility();
return bug;
}
static unsigned long arch_rnd(unsigned int rndbits)
{
if (!(current->flags & PF_RANDOMIZE))
return 0;
return (get_random_long() & ((1UL << rndbits) - 1)) << PAGE_SHIFT;
}
static unsigned long arch_rnd(unsigned int rndbits)
{
return (get_random_long() & ((1UL << rndbits) - 1)) << PAGE_SHIFT;
}
