void do_earthshatter( CHAR_DATA *ch, char *argument)
{
CHAR_DATA *vch;
CHAR_DATA *vch_next;
int dam;
int level;
if (IS_NPC(ch)) return;
if (!IS_CLASS(ch, CLASS_DROW) || !IS_SET(ch->pcdata->powers[1], DPOWER_EARTHSHATTER)) {
send_to_char("Huh?\n\r", ch );
return;}
if (ch->mana < 150) {
send_to_char("You need more mana.\n\r", ch );
return;}
level = ch->spl[PURPLE_MAGIC];
ch->mana -= 150;
send_to_char("You summon the power of the underworld, shattering the earth.\n\r", ch );
act("$n causes the earth to shatter",ch,NULL,NULL,TO_ROOM);
for ( vch = ch->in_room->people; vch != NULL; vch = vch_next )
{
vch_next = vch->next_in_room;
if (vch == ch) continue;
if (vch->trust>6) continue;
dam = dice(level, 7 );
if ( saves_spell( level, vch ) )
dam /= 2;
damage( ch, vch, dam, skill_lookup("earthquake"));
}
WAIT_STATE(ch, 12);
return;
}
//--------------------------------------------------------------
// mouse pressed
void mgSimpleDesktop::mouseDown(
void* source,
int x,
int y,
int modifiers,
int button)
{
#ifdef WORKED
// takeKeyFocus();
mgDimension size;
getSize(size);
mgRectangle inside(0, 0, size.m_width, size.m_height);
if (m_upFrame != NULL)
m_upFrame->getInsideRect(inside);
// =-= select entry under point
y = y - inside.m_y;
int index = (y/m_lineHeight) + m_scrollPosn;
if (index < m_entries.length())
{
if (m_multiSelect)
{
// =-= shift select, cntl select, start of drag select
// =-= reset all other selections if just click
mgListEntry* entry = (mgListEntry*) m_entries.getAt(index);
entry->m_selected = true;
}
else
{
m_selected = index;
}
damage();
}
#endif
}
void Character::spell_earthquake (int sn, int lvl, void *vo)
{
send_to_char ("The earth trembles beneath your feet!\r\n");
act ("$n makes the earth tremble and shiver.", NULL, NULL, TO_ROOM);
CharIter c, next;
for (c = char_list.begin(); c != char_list.end(); c = next) {
Character* vch = *c;
next = ++c;
if (vch->in_room == NULL)
continue;
if (vch->in_room == in_room) {
if (vch != this && (is_npc () ? !vch->is_npc () : vch->is_npc ()))
damage (this, vch, lvl + dice (2, 8), sn);
continue;
}
if (vch->in_room->area == in_room->area)
vch->send_to_char ("The earth trembles and shivers.\r\n");
}
return;
}
void Text::eraseLine()
{
if (insertion_.line_ < text_->Height())
{
int oldWidth = text_->Width();
int index0 = text_->LineIndex(insertion_.line_);
int index1 = text_->BeginningOfNextLine(index0);
// ---- delete the text ----
text_->Delete(index0, index1 - index0);
// --- check for width change ----
if (text_->Width() != oldWidth)
{
needWidth_ = true;
notify_all();
}
}
insertion_.column_ = 0;
repair();
damage(insertion_);
repair();
}
/*
* Drain XP, MANA, HP.
* Caster gains HP.
*/
void Character::spell_energy_drain (int sn, int lvl, void *vo)
{
Character *victim = (Character *) vo;
int dam;
if (victim->saves_spell (lvl))
return;
alignment = std::max (-1000, alignment - 200);
if (victim->level <= 2) {
dam = hit + 1;
} else {
victim->gain_exp(0 - number_range (lvl / 2, 3 * lvl / 2));
victim->mana /= 2;
victim->move /= 2;
dam = dice (1, lvl);
hit += dam;
}
damage (this, victim, dam, sn);
return;
}
void Character::spell_dispel_evil (int sn, int lvl, void *vo)
{
Character *victim = (Character *) vo;
if (!is_npc () && is_evil ())
victim = this;
if (victim->is_good ()) {
act ("God protects $N.", NULL, victim, TO_ROOM);
return;
}
if (victim->is_neutral ()) {
act ("$N does not seem to be affected.", NULL, victim, TO_CHAR);
return;
}
int dam = dice (lvl, 4);
if (victim->saves_spell (lvl))
dam /= 2;
damage (this, victim, dam, sn);
return;
}
void Fl_Sparkline::draw(void)
{
int i;
int index;
width = w() - padding * 2;
height = h() - padding * 2;
if (num_values == 0) {
draw_box();
return;
}
if (damage() == FL_DAMAGE_USER1) {
index = num_values * (Fl::event_x() - x() - padding) / width;
index = snap(index);
tip->position(Fl::event_x_root() + 10, Fl::event_y_root() + 10);
tip->value(values[index]);
tip->show();
drawCursor();
return;
}
draw_box();
fl_color(FL_BLACK);
drawPeaks();
fl_color(FL_BLACK);
for (i = 0; i < width; i++) {
drawPoint(i);
}
draw_label();
}
void Character::spell_frost_breath (int sn, int lvl, void *vo)
{
Character *victim = (Character *) vo;
if (number_percent () < 2 * lvl && !victim->saves_spell (lvl)) {
Object *obj_lose;
ObjIter o, onext;
for (o = victim->carrying.begin(); o != victim->carrying.end(); o = onext) {
obj_lose = *o;
onext = ++o;
const char *msg;
if (number_percent() <= 75)
continue;
switch (obj_lose->item_type) {
default:
continue;
case ITEM_CONTAINER:
case ITEM_DRINK_CON:
case ITEM_POTION:
msg = "$p freezes and shatters!";
break;
}
victim->act (msg, obj_lose, NULL, TO_CHAR);
obj_lose->extract_obj ();
}
}
int hpch = std::max (10, hit);
int dam = number_range (hpch / 16 + 1, hpch / 8);
if (victim->saves_spell (lvl))
dam /= 2;
damage (this, victim, dam, sn);
return;
}
//--------------------------------------------------------------
// character typed
void mgSimpleField::keyChar(
void* source,
int keyCode,
int modifiers)
{
if (!iswprint(keyCode) && keyCode != ' ')
return; // non-letter key
WCHAR keyChar[2];
keyChar[0] = (WCHAR) keyCode;
keyChar[1] = '\0';
mgString letter(keyChar);
if (m_insertMode)
{
// extend string up to cursor position
while (m_text.length() < m_cursorPosn)
m_text += " ";
// insert character at cursor
m_text.insertAt(m_cursorPosn, letter);
}
else
{
// extend string, including cursor position
while (m_text.length() <= m_cursorPosn)
m_text += " ";
// replace current character
m_text.setLetter(m_cursorPosn, letter);
}
m_cursorPosn = m_text.nextLetter(m_cursorPosn);
updateScrollPosn();
m_changed = true;
damage();
}
//--------------------------------------------------------------
// mouse moved
void mgUglyList::mouseMove(
void* source,
int x,
int y,
int modifiers)
{
mgDimension size;
getSize(size);
mgRectangle inside(0, 0, size.m_width, size.m_height);
if (m_upFrame != NULL)
m_upFrame->getInsideRect(inside);
// find entry under point
y = y - inside.m_y;
int index = (y/m_lineHeight) + m_scrollPosn;
if (index < m_entries.length())
{
m_hover = index;
damage();
}
else m_hover = -1;
}
void
warp(int fl, int c, double d)
{
int course;
double power;
double dist;
double p_time;
double speed;
double frac;
int percent;
int i;
char *s;
if (Ship.cond == DOCKED) {
printf("%s is docked\n", Ship.shipname);
return;
}
if (damaged(WARP)) {
out(WARP);
return;
}
course = c;
dist = d;
/* check to see that we are not using an absurd amount of power */
power = (dist + 0.05) * Ship.warp3;
percent = 100 * power / Ship.energy + 0.5;
if (percent >= 85) {
printf("Scotty: That would consume %d%% of our remaining energy.\n",
percent);
if (!getynpar("Are you sure that is wise"))
return;
}
/* compute the speed we will move at, and the time it will take */
speed = Ship.warp2 / Param.warptime;
p_time = dist / speed;
/* check to see that that value is not ridiculous */
percent = 100 * p_time / Now.time + 0.5;
if (percent >= 85) {
printf("Spock: That would take %d%% of our remaining time.\n",
percent);
if (!getynpar("Are you sure that is wise"))
return;
}
/* compute how far we will go if we get damages */
if (Ship.warp > 6.0 && ranf(100) < 20 + 15 * (Ship.warp - 6.0)) {
frac = franf();
dist *= frac;
p_time *= frac;
damage(WARP, (frac + 1.0) * Ship.warp * (franf() + 0.25) * 0.20);
}
/* do the move */
Move.time = move(fl, course, p_time, speed);
/* see how far we actually went, and decrement energy appropriately */
dist = Move.time * speed;
Ship.energy -= dist * Ship.warp3 * (Ship.shldup + 1);
/* test for bizarre events */
if (Ship.warp <= 9.0)
return;
printf("\n\n ___ Speed exceeding warp nine ___\n\n");
sleep(2);
printf("Ship's safety systems malfunction\n");
sleep(2);
printf("Crew experiencing extreme sensory distortion\n");
sleep(4);
if (ranf(100) >= 100 * dist) {
printf("Equilibrium restored -- all systems normal\n");
return;
}
/* select a bizzare thing to happen to us */
percent = ranf(100);
if (percent < 70) {
/* time warp */
if (percent < 35 || !Game.snap) {
/* positive time warp */
p_time = (Ship.warp - 8.0) * dist * (franf() + 1.0);
Now.date += p_time;
printf("Positive time portal entered -- it is now Stardate %.2f\n",
Now.date);
for (i = 0; i < MAXEVENTS; i++) {
percent = Event[i].evcode;
if (percent == E_FIXDV || percent == E_LRTB)
Event[i].date += p_time;
}
return;
}
/* s/he got lucky: a negative time portal */
p_time = Now.date;
s = Etc.snapshot;
bmove(s, Quad, sizeof Quad);
bmove(s += sizeof Quad, Event, sizeof Event);
bmove(s += sizeof Event, &Now, sizeof Now);
printf("Negative time portal entered -- it is now Stardate %.2f\n",
Now.date);
for (i = 0; i < MAXEVENTS; i++)
if (Event[i].evcode == E_FIXDV)
reschedule(&Event[i], Event[i].date - p_time);
return;
}
/* test for just a lot of damage */
if (percent < 80)
lose(L_TOOFAST);
printf("Equilibrium restored -- extreme damage occurred to ship systems\n");
for (i = 0; i < NDEV; i++)
damage(i, (3.0 * (franf() + franf()) + 1.0) * Param.damfac[i]);
Ship.shldup = 0;
}
void Character::spell_cause_serious (int sn, int lvl, void *vo)
{
damage (this, (Character *) vo, dice (2, 8) + lvl / 2, sn);
return;
}
int cpptestai::CCppTestAI::HandleEvent(int topic, const void* data) {
if ( false == game->Me()->IsRunning() ) {
return 0;
}
switch (topic) {
case EVENT_INIT: {
game->Me()->Init();
break;
}
case EVENT_RELEASE: {
game->Me()->GameEnd();
break;
}
case EVENT_UPDATE: {
game->Me()->Update();
break;
}
case EVENT_UNIT_GIVEN: {
struct SUnitGivenEvent* evt = (struct SUnitGivenEvent*) data;
if(evt->unitId < 0){
game->SendToConsole("shard-runtime warning: unitgiven evt->unit < 0");
break;
}
CSpringUnit* u = game->GetUnitById(evt->unitId);
if (!u) {
u = game->CreateUnit(evt->unitId);
}
if (u) {
// it might not have been given to us! Could have been given to another team
if(game->GetTeamID() == u->Team()){
game->Me()->UnitGiven(u);
}
} else {
game->SendToConsole("shard-runtime warning: unitgiven unit NULL");
}
break;
}
case EVENT_UNIT_CREATED: {
struct SUnitCreatedEvent* evt = (struct SUnitCreatedEvent*) data;
if(evt->unit < 0){
game->SendToConsole("shard-runtime warning: unitcreated evt->unit < 0");
break;
}
CSpringUnit* u = game->CreateUnit(evt->unit);
if (u) {
game->Me()->UnitCreated(u);
} else {
game->SendToConsole("shard-runtime warning: unitcreated unit NULL");
}
break;
}
case EVENT_UNIT_FINISHED: {
struct SUnitFinishedEvent* evt = (struct SUnitFinishedEvent*) data;
if(evt->unit < 0){
game->SendToConsole("shard-runtime warning: unitfinished evt->unit < 0");
break;
}
CSpringUnit* u = game->GetUnitById(evt->unit);
if(u == 0){
u = game->CreateUnit(evt->unit);
}
if(u != 0){
game->Me()->UnitBuilt(u);
} else {
game->SendToConsole("shard-runtime warning: unitfinished unit NULL");
}
break;
}
case EVENT_UNIT_DESTROYED: {
struct SUnitDestroyedEvent* evt = (struct SUnitDestroyedEvent*) data;
if(evt->unit < 0){
game->SendToConsole("shard-runtime warning: unitdestroyed evt->unit < 0");
break;
}
CSpringUnit* u = game->GetUnitById(evt->unit);
if(!u) {
u = game->CreateUnit(evt->unit);
}
if(u){
game->Me()->UnitDead(u);
game->DestroyUnit(evt->unit);
} else {
game->SendToConsole("shard-runtime warning: unitdestroyed unit NULL");
}
break;
}
case EVENT_ENEMY_DESTROYED: {
struct SEnemyDestroyedEvent* evt = (struct SEnemyDestroyedEvent*) data;
if(evt->enemy < 0){
game->SendToConsole("shard-runtime warning: enemydestroyed evt->unit < 0");
break;
}
CSpringUnit* u = game->GetUnitById(evt->enemy);
if (!u) {
u = game->CreateUnit(evt->enemy);
}
/*if(u){
// @TODO: Add enemy dead event
game->Me()->UnitDead(u);
}*/
game->DestroyUnit(evt->enemy);
break;
}
case EVENT_ENEMY_CREATED: {
struct SEnemyCreatedEvent* evt = (struct SEnemyCreatedEvent*) data;
game->CreateUnit(evt->enemy);
break;
}
case EVENT_ENEMY_FINISHED: {
struct SEnemyFinishedEvent* evt = (struct SEnemyFinishedEvent*) data;
game->CreateUnit(evt->enemy);
break;
}
case EVENT_UNIT_DAMAGED: {
struct SUnitDamagedEvent* evt = (struct SUnitDamagedEvent*) data;
if(evt->unit < 0){
game->SendToConsole("shard-runtime warning: unitdamaged evt->unit < 0");
break;
}
CSpringDamage::Ptr damage(new CSpringDamage(game, callback, evt));
CSpringUnit* u = game->GetUnitById(evt->unit);
if (!u) {
u = game->CreateUnit(evt->unit);
}
//attacker is allowed to be -1 if attacker cannot be seen or determined.
CSpringUnit* a = NULL;
if (evt->attacker >= 0) {
a = game->GetUnitById(evt->attacker);
if (!a) {
game->CreateUnit(evt->attacker);
}
}
if(u) {
game->Me()->UnitDamaged(u,a,damage);
} else {
if (!u)
game->SendToConsole("shard-runtime warning: attacked unit not found.");
}
break;
}
case EVENT_UNIT_IDLE: {
struct SUnitIdleEvent* evt = (struct SUnitIdleEvent*) data;
if(evt->unit < 0){
game->SendToConsole("shard-runtime warning: unitidle evt->unit < 0");
break;
}
CSpringUnit* u = game->GetUnitById(evt->unit);
if (!u) {
game->CreateUnit(evt->unit);
}
if (u) {
game->Me()->UnitIdle(u);
} else {
game->SendToConsole("shard-runtime warning: unitidle unit was NULL");
}
break;
}
case EVENT_UNIT_MOVE_FAILED: {
struct SUnitMoveFailedEvent* evt = (struct SUnitMoveFailedEvent*) data;
if(evt->unit < 0){
game->SendToConsole("shard-runtime warning: SUnitMoveFailedEvent evt->unit < 0");
break;
}
CSpringUnit* u = game->GetUnitById(evt->unit);
if (!u) {
u = game->CreateUnit(evt->unit);
}
if (u) {
game->Me()->UnitMoveFailed(u);
} else {
game->SendToConsole("shard-runtime warning: Did not now about move failed unit");
}
break;
}
case EVENT_LUA_MESSAGE: {
struct SLuaMessageEvent* evt = (struct SLuaMessageEvent*) data;
game->Me()->GameMessage(evt->inData);
break;
}
default: {
break;
}
}
// signal: everything went OK
return 0;
}
void Character::spell_cause_light (int sn, int lvl, void *vo)
{
damage (this, (Character *) vo, dice (1, 8) + lvl / 3, sn);
return;
}
void Character::spell_cause_critical (int sn, int lvl, void *vo)
{
damage (this, (Character *) vo, dice (3, 8) + lvl - 6, sn);
return;
}
//--------------------------------------------------------------------
// damage entire bitmap
void mgGenSurface::damageAll()
{
damage(0, 0, m_surfaceWidth, m_surfaceHeight);
}
/*
* Every spell that does damage comes through here. This calculates the
* amount of damage, adds in any modifiers, determines what the saves are,
* tests for save and calls damage().
*
* -1 = dead, otherwise the amount of damage done.
*/
int mag_damage(int level, struct char_data *ch, struct char_data *victim,
int spellnum, int savetype)
{
int dam = 0;
if (victim == NULL || ch == NULL)
return (0);
switch (spellnum) {
/* Mostly mages */
case SPELL_MAGIC_MISSILE:
case SPELL_CHILL_TOUCH: /* chill touch also has an affect */
if (IS_MAGIC_USER(ch))
dam = dice(1, 8) + 1;
else
dam = dice(1, 6) + 1;
break;
case SPELL_BURNING_HANDS:
if (IS_MAGIC_USER(ch))
dam = dice(3, 8) + 3;
else
dam = dice(3, 6) + 3;
break;
case SPELL_SHOCKING_GRASP:
if (IS_MAGIC_USER(ch))
dam = dice(5, 8) + 5;
else
dam = dice(5, 6) + 5;
break;
case SPELL_LIGHTNING_BOLT:
if (IS_MAGIC_USER(ch))
dam = dice(7, 8) + 7;
else
dam = dice(7, 6) + 7;
break;
case SPELL_COLOR_SPRAY:
if (IS_MAGIC_USER(ch))
dam = dice(9, 8) + 9;
else
dam = dice(9, 6) + 9;
break;
case SPELL_FIREBALL:
if (IS_MAGIC_USER(ch))
dam = dice(11, 8) + 11;
else
dam = dice(11, 6) + 11;
break;
/* Mostly clerics */
case SPELL_DISPEL_EVIL:
dam = dice(6, 8) + 6;
if (IS_EVIL(ch)) {
victim = ch;
dam = GET_HIT(ch) - 1;
} else if (IS_GOOD(victim)) {
act("The gods protect $N.", FALSE, ch, 0, victim, TO_CHAR);
return (0);
}
break;
case SPELL_DISPEL_GOOD:
dam = dice(6, 8) + 6;
if (IS_GOOD(ch)) {
victim = ch;
dam = GET_HIT(ch) - 1;
} else if (IS_EVIL(victim)) {
act("The gods protect $N.", FALSE, ch, 0, victim, TO_CHAR);
return (0);
}
break;
case SPELL_CALL_LIGHTNING:
dam = dice(7, 8) + 7;
break;
case SPELL_HARM:
dam = dice(8, 8) + 8;
break;
case SPELL_ENERGY_DRAIN:
if (GET_LEVEL(victim) <= 2)
dam = 100;
else
dam = dice(1, 10);
break;
/* Area spells */
case SPELL_EARTHQUAKE:
dam = dice(2, 8) + level;
break;
} /* switch(spellnum) */
/* divide damage by two if victim makes his saving throw */
if (mag_savingthrow(victim, savetype, 0))
dam /= 2;
/* and finally, inflict the damage */
return (damage(ch, victim, dam, spellnum));
}
void Fl_Overlay_Window::redraw_overlay()
{
overlay_ = this;
set_damage(damage()|FL_DAMAGE_OVERLAY);
Fl::damage(FL_DAMAGE_CHILD);
}
void Player::bounce(Player * other) {
SDL_Rect * rect, * source;
rect = last_position;
source = other->last_position;
int l, r, t, b;
int ls, rs, ts, bs;
bool is_above, is_below;
bool is_left, is_right;
l = rect->x;
t = rect->y;
r = rect->x + rect->w;
b = rect->y + rect->h;
ls = source->x;
ts = source->y;
rs = source->x + source->w;
bs = source->y + source->h;
if(l - ls > (WINDOW_WIDTH / 2)) {
ls += WINDOW_WIDTH;
rs += WINDOW_WIDTH;
}
if(ls - l > (WINDOW_WIDTH / 2)) {
l += WINDOW_WIDTH;
r += WINDOW_WIDTH;
}
is_above = (b <= ts);
is_below = (t >= bs);
is_left = (r <= ls);
is_right = (l >= rs);
if(!is_above && !is_below && !is_left && !is_right) {
if(bounce_direction_y == -1) is_above = true;
if(bounce_direction_y == 1) is_below = true;
if(bounce_direction_x == -1) is_left = true;
if(bounce_direction_x == 1) is_right = true;
}
// Players hit each others top
if(is_above) {
bounce_direction_y = -1;
if(input->is_pressed(A_JUMP)) {
Main::audio->play(SND_JUMP, position->x);
momentumy = MAX_MOMENTUM_JUMP;
is_falling = false;
is_jumping = true;
} else {
momentumy = 30;
}
}
if(is_below) {
bounce_direction_y = 1;
is_duck_forced = true;
duck_force_start = Gameplay::frame;
momentumy = -10;
if(damage(WEIGHTCLASSES[other->weightclass].headjump_damage)) {
other->headstomps++;
}
}
if(!is_above && !is_below) {
bounce_direction_y = 0;
}
newmomentumx = momentumx;
// Players hit each others side
if(is_left || is_right) {
newmomentumx = other->momentumx;
if(is_left) {
bounce_direction_x = -1;
newmomentumx -= WEIGHTCLASSES[other->weightclass].push_force - WEIGHTCLASSES[weightclass].push_force + 10;
}
if(is_right) {
bounce_direction_x = 1;
newmomentumx += WEIGHTCLASSES[other->weightclass].push_force - WEIGHTCLASSES[weightclass].push_force + 10;
}
} else {
bounce_direction_x = 0;
}
}
//--------------------------------------------------------------
// set default text color
void mgFormPane::setDefaultTextColor(
const mgColor& color)
{
m_defaultTextColor = color;
damage();
}
/* argument is set if attack while resting */
void
attack(int resting)
{
int hit, i, l;
int maxhit, tothit, shldabsb;
double chgfac, propor, extradm;
double dustfac, tothe;
int cas;
int hitflag;
if (Move.free)
return;
if (Etc.nkling <= 0 || Quad[Ship.quadx][Ship.quady].stars < 0)
return;
if (Ship.cloaked && Ship.cloakgood)
return;
/* move before attack */
klmove(0);
if (Ship.cond == DOCKED)
{
if (!resting)
printf("Starbase shields protect the %s\n", Ship.shipname);
return;
}
/* setup shield effectiveness */
chgfac = 1.0;
if (Move.shldchg)
chgfac = 0.25 + 0.50 * franf();
maxhit = tothit = 0;
hitflag = 0;
/* let each Klingon do his damndest */
for (i = 0; i < Etc.nkling; i++)
{
/* if he's low on power he won't attack */
if (Etc.klingon[i].power < 20)
continue;
if (!hitflag)
{
printf("\nStardate %.2f: Klingon attack:\n",
Now.date);
hitflag++;
}
/* complete the hit */
dustfac = 0.90 + 0.01 * franf();
tothe = Etc.klingon[i].avgdist;
hit = Etc.klingon[i].power * pow(dustfac, tothe) * Param.hitfac;
/* deplete his energy */
dustfac = Etc.klingon[i].power;
Etc.klingon[i].power = dustfac * Param.phasfac * (1.0 + (franf() - 0.5) * 0.2);
/* see how much of hit shields will absorb */
shldabsb = 0;
if (Ship.shldup || Move.shldchg)
{
propor = Ship.shield;
propor /= Param.shield;
shldabsb = propor * chgfac * hit;
if (shldabsb > Ship.shield)
shldabsb = Ship.shield;
Ship.shield -= shldabsb;
}
/* actually do the hit */
printf("\aHIT: %d units", hit);
if (!damaged(SRSCAN))
printf(" from %d,%d", Etc.klingon[i].x, Etc.klingon[i].y);
cas = (shldabsb * 100) / hit;
hit -= shldabsb;
if (shldabsb > 0)
printf(", shields absorb %d%%, effective hit %d\n",
cas, hit);
else
printf("\n");
tothit += hit;
if (hit > maxhit)
maxhit = hit;
Ship.energy -= hit;
/* see if damages occurred */
if (hit >= (15 - Game.skill) * (25 - ranf(12)))
{
printf("\aCRITICAL HIT!!!\a\n");
/* select a device from probability vector */
cas = ranf(1000);
for (l = 0; cas >= 0; l++)
cas -= Param.damprob[l];
l -= 1;
/* compute amount of damage */
extradm = (hit * Param.damfac[l]) / (75 + ranf(25)) + 0.5;
/* damage the device */
damage(l, extradm);
if (damaged(SHIELD))
{
if (Ship.shldup)
printf("Sulu: Shields knocked down, captain.\n");
Ship.shldup = 0;
Move.shldchg = 0;
}
}
if (Ship.energy <= 0)
lose(L_DSTRYD);
}
/* see what our casualities are like */
if (maxhit >= 200 || tothit >= 500)
{
cas = tothit * 0.015 * franf();
if (cas >= 2)
{
printf("McCoy: we suffered %d casualties in that attack.\n",
cas);
Game.deaths += cas;
Ship.crew -= cas;
}
}
/* allow Klingons to move after attacking */
klmove(1);
}
/* Update PCs, NPCs, and objects */
void point_update(void)
{
struct char_data *i, *next_char;
struct obj_data *j, *next_thing, *jj, *next_thing2;
/* characters */
for (i = character_list; i; i = next_char) {
next_char = i->next;
gain_condition(i, FULL, -1);
gain_condition(i, DRUNK, -1);
gain_condition(i, THIRST, -1);
if (GET_POS(i) >= POS_STUNNED) {
GET_HIT(i) = MIN(GET_HIT(i) + hit_gain(i), GET_MAX_HIT(i));
GET_MANA(i) = MIN(GET_MANA(i) + mana_gain(i), GET_MAX_MANA(i));
GET_MOVE(i) = MIN(GET_MOVE(i) + move_gain(i), GET_MAX_MOVE(i));
if (AFF_FLAGGED(i, AFF_POISON))
if (damage(i, i, 2, SPELL_POISON) == -1)
continue; /* Oops, they died. -gg 6/24/98 */
if (GET_POS(i) <= POS_STUNNED)
update_pos(i);
} else if (GET_POS(i) == POS_INCAP) {
if (damage(i, i, 1, TYPE_SUFFERING) == -1)
continue;
} else if (GET_POS(i) == POS_MORTALLYW) {
if (damage(i, i, 2, TYPE_SUFFERING) == -1)
continue;
}
if (!IS_NPC(i)) {
update_char_objects(i);
if (GET_LEVEL(i) < idle_max_level)
check_idling(i);
}
}
/* objects */
for (j = object_list; j; j = next_thing) {
next_thing = j->next; /* Next in object list */
/* If this is a corpse */
if (IS_CORPSE(j)) {
/* timer count down */
if (GET_OBJ_TIMER(j) > 0)
GET_OBJ_TIMER(j)--;
if (!GET_OBJ_TIMER(j)) {
if (j->carried_by)
act("$p decays in your hands.", FALSE, j->carried_by, j, 0, TO_CHAR);
else if ((IN_ROOM(j) != NOWHERE) && (world[IN_ROOM(j)].people)) {
act("A quivering horde of maggots consumes $p.",
TRUE, world[IN_ROOM(j)].people, j, 0, TO_ROOM);
act("A quivering horde of maggots consumes $p.",
TRUE, world[IN_ROOM(j)].people, j, 0, TO_CHAR);
}
for (jj = j->contains; jj; jj = next_thing2) {
next_thing2 = jj->next_content; /* Next in inventory */
obj_from_obj(jj);
if (j->in_obj)
obj_to_obj(jj, j->in_obj);
else if (j->carried_by)
obj_to_room(jj, IN_ROOM(j->carried_by));
else if (IN_ROOM(j) != NOWHERE)
obj_to_room(jj, IN_ROOM(j));
else
core_dump();
}
extract_obj(j);
}
}
/* If the timer is set, count it down and at 0, try the trigger */
/* note to .rej hand-patchers: make this last in your point-update() */
else if (GET_OBJ_TIMER(j)>0) {
GET_OBJ_TIMER(j)--;
if (!GET_OBJ_TIMER(j))
timer_otrigger(j);
}
}
}
//--------------------------------------------------------------
// set control frame
void mgFormPane::setFrame(
const mgFrame* frame)
{
m_frame = frame;
damage();
}
int Desktop::handle(int event) {
switch(event) {
case FL_FOCUS:
case FL_UNFOCUS:
case FL_SHORTCUT:
return 1;
case FL_PUSH: {
/*
* First check where we clicked. If we do it on desktop unfocus any possible focused childs, and handle
* specific clicks. Otherwise, do rest for childs.
*/
Fl_Widget* clicked = Fl::belowmouse();
if(NOT_SELECTABLE(clicked)) {
//E_DEBUG(E_STRLOC ": DESKTOP CLICK !!!\n");
if(!selectionbuf.empty()) {
/*
* Only focused are in selectionbuf, so this is fine to do; also will prevent
* full redraw when is clicked on desktop
*/
unfocus_all();
selectionbuf.clear();
}
/* track position so moving can be deduced */
if(Fl::event_button() == 1) {
selbox->x = Fl::event_x();
selbox->y = Fl::event_y();
} else if(Fl::event_button() == 3) {
last_px = Fl::event_x();
last_py = Fl::event_y();
damage(EDE_DESKTOP_DAMAGE_OVERLAY);
const edelib::MenuItem* item = dmenu->menu()->popup(Fl::event_x(), Fl::event_y());
dmenu->picked(item);
}
return 1;
}
/* from here, all events are managed for icons */
DesktopIcon* tmp_icon = (DesktopIcon*)clicked;
/* do no use assertion on this, since fltk::belowmouse() can miss our icon */
if(!tmp_icon) return 1;
if(SELECTION_MULTI) {
Fl::event_is_click(0);
select(tmp_icon);
return 1;
} else if(SELECTION_SINGLE) {
if(!in_selection(tmp_icon)) {
select_only(tmp_icon);
}
} else if(Fl::event_button() == 3) {
select_only(tmp_icon);
}
/*
* Let child handle the rest.
* Also prevent click on other mouse buttons during move.
*/
if(!moving)
tmp_icon->handle(FL_PUSH);
//E_DEBUG(E_STRLOC ": FL_PUSH from desktop\n");
selection_x = Fl::event_x_root();
selection_y = Fl::event_y_root();
return 1;
}
case FL_DRAG:
moving = true;
if(!selectionbuf.empty()) {
//E_DEBUG(E_STRLOC ": DRAG icon from desktop\n");
move_selection(Fl::event_x_root(), Fl::event_y_root(), false);
} else {
//E_DEBUG(E_STRLOC ": DRAG from desktop\n");
/*
* Moving is started with pushed button.
* From this point selection box is created and is rolled until release
*/
if(selbox->x != 0 || selbox->y != 0) {
selbox->w = Fl::event_x() - selbox->x;
selbox->h = Fl::event_y() - selbox->y;
selbox->show = true;
/* see if there some icons inside selection area */
select_in_area();
/* redraw selection box */
damage(EDE_DESKTOP_DAMAGE_OVERLAY);
}
}
return 1;
case FL_RELEASE:
//E_DEBUG(E_STRLOC ": RELEASE from desktop\n");
//E_DEBUG(E_STRLOC ": clicks: %i\n", Fl::event_is_click());
if(selbox->show) {
selbox->x = selbox->y = selbox->w = selbox->h = 0;
selbox->show = false;
damage(EDE_DESKTOP_DAMAGE_OVERLAY);
/*
* Now pickup those who are in is_focused() state.
*
* Possible flickers due overlay will be later removed when is called move_selection(), which
* will in turn redraw icons again after position them.
*/
if(!selectionbuf.empty())
selectionbuf.clear();
DesktopIcon *o;
for(int i = 0; i < children(); i++) {
if(NOT_SELECTABLE(child(i))) continue;
o = (DesktopIcon*)child(i);
if(o->is_focused())
select(o, false);
}
return 1;
}
if(!selectionbuf.empty() && moving)
move_selection(Fl::event_x_root(), Fl::event_y_root(), true);
/*
* Do not send FL_RELEASE during move
* TODO: should be alowed FL_RELEASE to multiple icons? (aka. run command for all selected icons)?
*/
if(selectionbuf.size() == 1 && !moving)
selectionbuf.front()->handle(FL_RELEASE);
moving = false;
return 1;
case FL_DND_ENTER:
case FL_DND_DRAG:
case FL_DND_LEAVE:
return 1;
case FL_DND_RELEASE: {
DesktopIcon* di = below_mouse(Fl::event_x(), Fl::event_y());
if(di) return di->handle(event);
return 1;
}
case FL_PASTE: {
DesktopIcon* di = below_mouse(Fl::event_x(), Fl::event_y());
if(di) return di->handle(event);
return 1;
}
case FL_ENTER:
case FL_LEAVE:
case FL_MOVE:
return EDE_DESKTOP_WINDOW::handle(event);
default:
break;
}
return 0;
}
//--------------------------------------------------------------
// set default font size
void mgFormPane::setDefaultFontSize(
int size)
{
m_defaultFontSize = size;
damage();
}
//--------------------------------------------------------------
// set default font face
void mgFormPane::setDefaultFontFace(
const char* faceName)
{
m_defaultFontFace = faceName;
damage();
}
/*
* Set off a trap (obj) upon character (ch) - Thoric
*/
ch_ret spring_trap( char_data * ch, obj_data * obj )
{
int dam, typ, lev;
const char *txt;
ch_ret retcode;
typ = obj->value[1];
lev = obj->value[2];
retcode = rNONE;
switch ( typ )
{
default:
txt = "hit by a trap";
break;
case TRAP_TYPE_POISON_GAS:
txt = "surrounded by a green cloud of gas";
break;
case TRAP_TYPE_POISON_DART:
txt = "hit by a dart";
break;
case TRAP_TYPE_POISON_NEEDLE:
txt = "pricked by a needle";
break;
case TRAP_TYPE_POISON_DAGGER:
txt = "stabbed by a dagger";
break;
case TRAP_TYPE_POISON_ARROW:
txt = "struck with an arrow";
break;
case TRAP_TYPE_BLINDNESS_GAS:
txt = "surrounded by a red cloud of gas";
break;
case TRAP_TYPE_SLEEPING_GAS:
txt = "surrounded by a yellow cloud of gas";
break;
case TRAP_TYPE_FLAME:
txt = "struck by a burst of flame";
break;
case TRAP_TYPE_EXPLOSION:
txt = "hit by an explosion";
break;
case TRAP_TYPE_ACID_SPRAY:
txt = "covered by a spray of acid";
break;
case TRAP_TYPE_ELECTRIC_SHOCK:
txt = "suddenly shocked";
break;
case TRAP_TYPE_BLADE:
txt = "sliced by a razor sharp blade";
break;
case TRAP_TYPE_SEX_CHANGE:
txt = "surrounded by a mysterious aura";
break;
}
dam = number_range( obj->value[4], obj->value[5] );
act_printf( AT_HITME, ch, NULL, NULL, TO_CHAR, "You are %s!", txt );
act_printf( AT_ACTION, ch, NULL, NULL, TO_ROOM, "$n is %s.", txt );
--obj->value[0];
if( obj->value[0] <= 0 )
obj->extract( );
switch ( typ )
{
default:
case TRAP_TYPE_BLADE:
retcode = damage( ch, ch, dam, TYPE_UNDEFINED );
break;
case TRAP_TYPE_POISON_DART:
case TRAP_TYPE_POISON_NEEDLE:
case TRAP_TYPE_POISON_DAGGER:
case TRAP_TYPE_POISON_ARROW:
retcode = obj_cast_spell( gsn_poison, lev, ch, ch, NULL );
if( retcode == rNONE )
retcode = damage( ch, ch, dam, TYPE_UNDEFINED );
break;
case TRAP_TYPE_POISON_GAS:
retcode = obj_cast_spell( gsn_poison, lev, ch, ch, NULL );
break;
case TRAP_TYPE_BLINDNESS_GAS:
retcode = obj_cast_spell( gsn_blindness, lev, ch, ch, NULL );
break;
case TRAP_TYPE_SLEEPING_GAS:
retcode = obj_cast_spell( skill_lookup( "sleep" ), lev, ch, ch, NULL );
break;
case TRAP_TYPE_ACID_SPRAY:
retcode = obj_cast_spell( skill_lookup( "acid blast" ), lev, ch, ch, NULL );
break;
case TRAP_TYPE_SEX_CHANGE:
retcode = obj_cast_spell( skill_lookup( "change sex" ), lev, ch, ch, NULL );
break;
case TRAP_TYPE_FLAME:
retcode = obj_cast_spell( skill_lookup( "flamestrike" ), lev, ch, ch, NULL );
break;
case TRAP_TYPE_EXPLOSION:
retcode = obj_cast_spell( gsn_fireball, lev, ch, ch, NULL );
break;
case TRAP_TYPE_ELECTRIC_SHOCK:
retcode = obj_cast_spell( skill_lookup( "lightning bolt" ), lev, ch, ch, NULL );
break;
}
return retcode;
}
// FlTk Event handler for the window
// TODO: if you want to make the train respond to other events
// (like key presses), you might want to hack this.
int TrainView::handle(int event)
{
// see if the ArcBall will handle the event - if it does, then we're done
// note: the arcball only gets the event if we're in world view
if (tw->worldCam->value())
if (arcball.handle(event)) return 1;
// remember what button was used
static int last_push;
switch(event) {
case FL_PUSH:
last_push = Fl::event_button();
if (last_push == 1) {
doPick();
damage(1);
return 1;
};
break;
case FL_RELEASE:
damage(1);
last_push=0;
return 1;
case FL_DRAG:
if ((last_push == 1) && (selectedCube >=0)) {
ControlPoint* cp = &world->points[selectedCube];
double r1x, r1y, r1z, r2x, r2y, r2z;
getMouseLine(r1x,r1y,r1z, r2x,r2y,r2z);
double rx, ry, rz;
mousePoleGo(r1x,r1y,r1z, r2x,r2y,r2z,
static_cast<double>(cp->pos.x),
static_cast<double>(cp->pos.y),
static_cast<double>(cp->pos.z),
rx, ry, rz,
(Fl::event_state() & FL_CTRL) != 0);
cp->pos.x = (float) rx;
cp->pos.y = (float) ry;
cp->pos.z = (float) rz;
damage(1);
}
break;
// in order to get keyboard events, we need to accept focus
case FL_FOCUS:
return 1;
case FL_ENTER: // every time the mouse enters this window, aggressively take focus
focus(this);
break;
case FL_KEYBOARD:
int k = Fl::event_key();
int ks = Fl::event_state();
if (k=='p') {
if (selectedCube >=0)
printf("Selected(%d) (%g %g %g) (%g %g %g)\n",selectedCube,
world->points[selectedCube].pos.x,world->points[selectedCube].pos.y,world->points[selectedCube].pos.z,
world->points[selectedCube].orient.x,world->points[selectedCube].orient.y,world->points[selectedCube].orient.z);
else
printf("Nothing Selected\n");
return 1;
};
break;
}
return Fl_Gl_Window::handle(event);
}
// MOBの攻撃
void mobAttack(mob_t m){
uchar fx, fy;
getFrontCoord(m.x, m.y, m.dir, &fx, &fy);
damage(fx, fy, m.attack);
}
/*
** doDisease
*/
void
doDisease(CharData* vict)
{
int poisonDamage = aff_level(vict, AFF_DISEASE) + number(1,10);
damage(vict, vict, poisonDamage, SPELL_DISEASE);
}
