ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/server/player.C
(Generate patch)

Comparing deliantra/server/server/player.C (file contents):
Revision 1.135 by root, Sun May 13 15:13:57 2007 UTC vs.
Revision 1.143 by root, Fri May 18 21:12:40 2007 UTC

… …
147 draw_ext_info_format (NDI_UNIQUE | NDI_GREEN, 0, op, 147 draw_ext_info_format (NDI_UNIQUE | NDI_GREEN, 0, op,
148 MSG_TYPE_ADMIN, MSG_TYPE_ADMIN_NEWS, "INFORMATION: %s\n%s\n", (char *)"%s\n%s", subject, news); 148 MSG_TYPE_ADMIN, MSG_TYPE_ADMIN_NEWS, "INFORMATION: %s\n%s\n", (char *)"%s\n%s", subject, news);
149 close_and_delete (fp, comp); 149 close_and_delete (fp, comp);
150} 150}
151 151
152float
153player::weapon_speed () const
154{
155 return ob->speed / weapon_sp * .5f;//TODO, the .5 is arbitrary
156}
157
158/* This loads the first map an puts the player on it. */ 152/* This loads the first map an puts the player on it. */
159static void 153static void
160set_first_map (object *op) 154set_first_map (object *op)
161{ 155{
162 op->contr->maplevel = first_map_path; 156 op->contr->maplevel = first_map_path;
… …
264 258
265 new_draw_info (NDI_UNIQUE, 0, ob, "Welcome Back!"); 259 new_draw_info (NDI_UNIQUE, 0, ob, "Welcome Back!");
266 260
267 esrv_new_player (this, ob->weight + ob->carrying); 261 esrv_new_player (this, ob->weight + ob->carrying);
268 262
263 ob->flag [FLAG_READY_WEAPON] = false;
264 ob->flag [FLAG_READY_SKILL] = false;
265 ob->flag [FLAG_READY_BOW] = false;
266
269 for (object *op = ob->inv; op; op = op->below) 267 for (object *op = ob->inv; op; op = op->below)
270 if (op->flag [FLAG_APPLIED]) 268 if (op->flag [FLAG_APPLIED])
271 switch (op->type) 269 switch (op->type)
272 { 270 {
271 case SKILL:
272 ob->flag [FLAG_APPLIED] = false;
273 break;
274
273 case WAND: 275 case WAND:
274 case ROD: 276 case ROD:
275 case HORN: 277 case HORN:
276 case BOW: 278 case BOW:
277 case SKILL: 279 ranged_ob = op;
278 case SKILL_TOOL: 280 break;
281
279 case WEAPON: 282 case WEAPON:
280 apply_special (ob, op, AP_UNAPPLY); 283 combat_ob = op;
281 apply_special (ob, op, AP_APPLY);
282 break; 284 break;
283 } 285 }
284 286
287 ob->change_weapon (combat_ob ? combat_ob : ranged_ob);
285 ob->update_stats (); 288 ob->update_stats ();
289
286 ns->floorbox_update (); 290 ns->floorbox_update ();
287
288 esrv_send_inventory (ob, ob); 291 esrv_send_inventory (ob, ob);
289 esrv_add_spells (this, 0); 292 esrv_add_spells (this, 0);
290 293
291 activate (); 294 activate ();
292 295
… …
325player::set_object (object *op) 328player::set_object (object *op)
326{ 329{
327 ob = op; 330 ob = op;
328 ob->contr = this; /* this aren't yet in archetype */ 331 ob->contr = this; /* this aren't yet in archetype */
329 332
330 ob->speed_left = 0.5f;
331 ob->speed = 1.0f; 333 ob->speed = 1.0f;
334 ob->speed_left = 0.5f;
335
332 ob->direction = 5; /* So player faces south */ 336 ob->direction = 5; /* So player faces south */
333} 337}
334 338
335player::player () 339player::player ()
336{ 340{
337 /* There are some elements we want initialised to non zero value - 341 /* There are some elements we want initialised to non zero value -
… …
348 petmode = pet_normal; 352 petmode = pet_normal;
349 listening = 10; 353 listening = 10;
350 usekeys = containers; 354 usekeys = containers;
351 peaceful = 1; /* default peaceful */ 355 peaceful = 1; /* default peaceful */
352 do_los = 1; 356 do_los = 1;
357
358 weapon_sp = 1.0f;
359 weapon_sp_left = 0.5f;
353} 360}
354 361
355void 362void
356player::do_destroy () 363player::do_destroy ()
357{ 364{
… …
1550 { 1557 {
1551 new_draw_info (NDI_UNIQUE, 0, op, "You can't shoot yourself!"); 1558 new_draw_info (NDI_UNIQUE, 0, op, "You can't shoot yourself!");
1552 return 0; 1559 return 0;
1553 } 1560 }
1554 1561
1555 if (player *pl = op->contr) 1562 if (op->contr)
1556 { 1563 bow = op->current_weapon;
1557 bow = pl->ranged_ob;
1558 if (!op->change_weapon (bow))
1559 return 0;
1560 }
1561 else 1564 else
1562 { 1565 {
1563 for (bow = op->inv; bow; bow = bow->below) 1566 for (bow = op->inv; bow; bow = bow->below)
1564 /* Don't check for applied - monsters don't apply bows - in that way, they 1567 /* Don't check for applied - monsters don't apply bows - in that way, they
1565 * don't need to switch back and forth between bows and weapons. 1568 * don't need to switch back and forth between bows and weapons.
… …
1636 arrow->stats.grace = arrow->attacktype; 1639 arrow->stats.grace = arrow->attacktype;
1637 1640
1638 if (arrow->slaying) 1641 if (arrow->slaying)
1639 arrow->spellarg = strdup (arrow->slaying); 1642 arrow->spellarg = strdup (arrow->slaying);
1640 1643
1644#if 0
1641 if (player *pl = op->contr) 1645 if (player *pl = op->contr)
1642 { 1646 {
1643 if (!pl->has_hit)
1644 {
1645 pl->has_hit = 1;
1646 pl->ob->speed_left += pl->weapon_speed () - pl->ob->speed;
1647 }
1648#if 0
1649 float speed = pl->weapon_sp; 1647 float speed = pl->weapon_sp;
1650 1648
1651 /* penalize ROF for bestarrow */ 1649 /* penalize ROF for bestarrow */
1652 if (pl->bowtype == bow_bestarrow) 1650 if (pl->bowtype == bow_bestarrow)
1653 speed *= .9f; 1651 speed *= .9f;
1654 else 1652 else
1655 speed *= 1.f + dex_bonus[op->stats.Dex] * .2f; 1653 speed *= 1.f + dex_bonus[op->stats.Dex] * .2f;
1656 1654
1657 op->speed_left += speed - op->speed; 1655 op->speed_left += speed - op->speed;
1656 }
1658#endif 1657#endif
1659 }
1660 1658
1661 SET_ANIMATION (arrow, arrow->direction); 1659 SET_ANIMATION (arrow, arrow->direction);
1662 1660
1663 /* update the speed */ 1661 /* update the speed */
1664 arrow->speed = ((bow->flag [FLAG_NO_STRENGTH] ? 0 : dam_bonus[op->stats.Str]) + bow->magic + arrow->magic) / 5.0 1662 arrow->speed = ((bow->flag [FLAG_NO_STRENGTH] ? 0 : dam_bonus[op->stats.Str]) + bow->magic + arrow->magic) / 5.f
1665 + bow->stats.dam / 7.0; 1663 + bow->stats.dam / 7.f;
1666 1664
1667 arrow->set_speed (max (arrow->speed, 2.0)); 1665 arrow->set_speed (max (arrow->speed, 2.f));
1668 arrow->speed_left = 0; 1666 arrow->speed_left = 0;
1669 1667
1670 int wc = op->stats.wc + wc_mod - arrow->magic - arrow->stats.wc; 1668 int wc = op->stats.wc + wc_mod - arrow->magic - arrow->stats.wc;
1671 1669
1672 if (op->type == PLAYER) 1670 if (op->type == PLAYER)
… …
1831 } 1829 }
1832} 1830}
1833 1831
1834/* Received a fire command for the player - go and do it. 1832/* Received a fire command for the player - go and do it.
1835 */ 1833 */
1836void 1834bool
1837fire (object *op, int dir) 1835fire (object *op, int dir)
1838{ 1836{
1839 int spellcost = 0; 1837 int spellcost = 0;
1840 1838
1841 /* check for loss of invisiblity/hide */ 1839 /* check for loss of invisiblity/hide */
… …
1845 player *pl = op->contr; 1843 player *pl = op->contr;
1846 1844
1847 if (pl->golem) 1845 if (pl->golem)
1848 { 1846 {
1849 control_golem (op->contr->golem, dir); 1847 control_golem (op->contr->golem, dir);
1850 return; 1848 return false;
1851 } 1849 }
1852 1850
1853 object *ob = pl->ranged_ob; 1851 object *ob = pl->ranged_ob;
1854 1852
1855 if (!ob) 1853 if (!ob)
1856 return; 1854 return false;
1855
1856 if (!op->change_weapon (ob))
1857 return false;
1858
1859 if (op->speed_left > 0.f)
1860 --op->speed_left;
1861 else
1862 return false;
1857 1863
1858 switch (ob->type) 1864 switch (ob->type)
1859 { 1865 {
1860 case BOW: 1866 case BOW:
1861 player_fire_bow (op, dir); 1867 player_fire_bow (op, dir);
… …
1868 case BUILDER: 1874 case BUILDER:
1869 apply_map_builder (op, dir); 1875 apply_map_builder (op, dir);
1870 break; 1876 break;
1871 1877
1872 case SKILL: 1878 case SKILL:
1873 case SKILL_TOOL:
1874 do_skill (op, op, ob, dir, 0); 1879 do_skill (op, op, ob, dir, 0);
1875 break; 1880 break;
1876 1881
1877 default: 1882 default:
1878 fire_misc_object (op, dir); 1883 fire_misc_object (op, dir);
1879 break; 1884 break;
1880 } 1885 }
1886
1887 return true;
1881} 1888}
1882 1889
1883/* find_key 1890/* find_key
1884 * We try to find a key for the door as passed. If we find a key 1891 * We try to find a key for the door as passed. If we find a key
1885 * and successfully use it, we return the key, otherwise NULL 1892 * and successfully use it, we return the key, otherwise NULL
… …
1972 * 0 otherwise 1979 * 0 otherwise
1973 */ 1980 */
1974static int 1981static int
1975player_attack_door (object *op, object *door) 1982player_attack_door (object *op, object *door)
1976{ 1983{
1977 /* If its a door, try to find a use a key. If we do destroy the door, 1984 /* If its a door, try to find a key. If we do destroy the door,
1978 * might as well return immediately as there is nothing more to do - 1985 * might as well return immediately as there is nothing more to do -
1979 * otherwise, we fall through to the rest of the code. 1986 * otherwise, we fall through to the rest of the code.
1980 */ 1987 */
1981 object *key = find_key (op, op, door); 1988 object *key = find_key (op, op, door);
1982 1989
1983 /* IF we found a key, do some extra work */ 1990 /* If we found a key, do some extra work */
1984 if (key) 1991 if (key)
1985 { 1992 {
1986 object *container = key->env; 1993 object *container = key->env;
1987 1994
1988 play_sound_map (op->map, op->x, op->y, SOUND_OPEN_DOOR); 1995 play_sound_map (op->map, op->x, op->y, SOUND_OPEN_DOOR);
… …
2023 * It should keep the code cleaner. 2030 * It should keep the code cleaner.
2024 * When this is called, the players direction has been updated 2031 * When this is called, the players direction has been updated
2025 * (taking into account confusion.) The player is also actually 2032 * (taking into account confusion.) The player is also actually
2026 * going to try and move (not fire weapons). 2033 * going to try and move (not fire weapons).
2027 */ 2034 */
2028void 2035bool
2029move_player_attack (object *op, int dir) 2036move_player_attack (object *op, int dir)
2030{ 2037{
2031 object *tmp, *mon;
2032 int on_battleground; 2038 int on_battleground;
2033 maptile *m;
2034 2039
2035 sint16 nx = freearr_x[dir] + op->x; 2040 sint16 nx = freearr_x[dir] + op->x;
2036 sint16 ny = freearr_y[dir] + op->y; 2041 sint16 ny = freearr_y[dir] + op->y;
2037 2042
2038 on_battleground = op_on_battleground (op, 0, 0); 2043 on_battleground = op_on_battleground (op, 0, 0);
2044
2045 if (out_of_map (op->map, nx, ny))
2046 return false;
2047
2048 if (!op->contr->braced && op->speed_left > 0.f && move_ob (op, dir, op))
2049 {
2050 --op->speed_left;
2051 return true;
2052 }
2039 2053
2040 /* If braced, or can't move to the square, and it is not out of the 2054 /* If braced, or can't move to the square, and it is not out of the
2041 * map, attack it. Note order of if statement is important - don't 2055 * map, attack it. Note order of if statement is important - don't
2042 * want to be calling move_ob if braced, because move_ob will move the 2056 * want to be calling move_ob if braced, because move_ob will move the
2043 * player. This is a pretty nasty hack, because if we could 2057 * player. This is a pretty nasty hack, because if we could
2044 * move to some space, it then means that if we are braced, we should 2058 * move to some space, it then means that if we are braced, we should
2045 * do nothing at all. As it is, if we are braced, we go through 2059 * do nothing at all. As it is, if we are braced, we go through
2046 * quite a bit of processing. However, it probably is less than what 2060 * quite a bit of processing. However, it probably is less than what
2047 * move_ob uses. 2061 * move_ob uses.
2048 */ 2062 */
2049 if ((op->contr->braced || !move_ob (op, dir, op)) && !out_of_map (op->map, nx, ny))
2050 {
2051 if (OUT_OF_REAL_MAP (op->map, nx, ny))
2052 {
2053 m = op->map->xy_find (nx, ny); 2063 maptile *m = op->map->xy_find (nx, ny);
2054 if (!m)
2055 return; /* Don't think this should happen */
2056 }
2057 else
2058 m = op->map;
2059 2064
2060 if (!(tmp = m->at (nx, ny).bot))
2061 return;
2062
2063 mon = 0;
2064 /* Go through all the objects, and find ones of interest. Only stop if 2065 /* Go through all the objects, and find ones of interest. Only stop if
2065 * we find a monster - that is something we know we want to attack. 2066 * we find a monster - that is something we know we want to attack.
2066 * if its a door or barrel (can roll) see if there may be monsters 2067 * if its a door or barrel (can roll) see if there may be monsters
2067 * on the space 2068 * on the space
2068 */ 2069 */
2069 while (tmp) 2070 object *mon;
2070 { 2071 for (mon = m->at (nx, ny).bot; mon; mon = mon->above)
2071 if (tmp == op) 2072 {
2072 { 2073 if ((mon->flag [FLAG_ALIVE]
2073 tmp = tmp->above; 2074 || mon->type == LOCKED_DOOR
2074 continue; 2075 || mon->flag [FLAG_CAN_ROLL])
2075 }
2076
2077 if (QUERY_FLAG (tmp, FLAG_ALIVE))
2078 {
2079 mon = tmp; 2076 && mon != op)
2080 break; 2077 break;
2081 } 2078 }
2082 2079
2083 if (tmp->type == LOCKED_DOOR || QUERY_FLAG (tmp, FLAG_CAN_ROLL))
2084 mon = tmp;
2085
2086 tmp = tmp->above;
2087 }
2088
2089 if (!mon) /* This happens anytime the player tries to move */ 2080 if (!mon) /* This happens anytime the player tries to move */
2090 return; /* into a wall */ 2081 return false; /* into a wall */
2091 2082
2092 if (mon->head)
2093 mon = mon->head; 2083 mon = mon->head_ ();
2094 2084
2095 if ((mon->type == DOOR && mon->stats.hp >= 0) || (mon->type == LOCKED_DOOR)) 2085 if ((mon->type == DOOR && mon->stats.hp >= 0) || (mon->type == LOCKED_DOOR))
2086 if (op->contr->weapon_sp_left > 0.f)
2096 if (player_attack_door (op, mon)) 2087 if (player_attack_door (op, mon))
2088 {
2089 --op->contr->weapon_sp_left;
2097 return; 2090 return true;
2091 }
2098 2092
2099 /* The following deals with possibly attacking peaceful 2093 /* The following deals with possibly attacking peaceful
2100 * or frienddly creatures. Basically, all players are considered 2094 * or friendly creatures. Basically, all players are considered
2101 * unaggressive. If the moving player has peaceful set, then the 2095 * unaggressive. If the moving player has peaceful set, then the
2102 * object should be pushed instead of attacked. It is assumed that 2096 * object should be pushed instead of attacked. It is assumed that
2103 * if you are braced, you will not attack friends accidently, 2097 * if you are braced, you will not attack friends accidently,
2104 * and thus will not push them. 2098 * and thus will not push them.
2105 */ 2099 */
2106 2100
2107 /* If the creature is a pet, push it even if the player is not 2101 /* If the creature is a pet, push it even if the player is not
2108 * peaceful. Our assumption is the creature is a pet if the 2102 * peaceful. Our assumption is the creature is a pet if the
2109 * player owns it and it is either friendly or unagressive. 2103 * player owns it and it is either friendly or unagressive.
2110 */ 2104 */
2111 if ((op->type == PLAYER) 2105 if (op->type == PLAYER
2112#if COZY_SERVER
2113 &&
2114 ((mon->owner && mon->owner->contr 2106 && ((mon->owner && mon->owner->contr
2115 && same_party (mon->owner->contr->party, op->contr->party)) || mon->owner == op) 2107 && same_party (mon->owner->contr->party, op->contr->party))
2116#else
2117 && mon->owner == op 2108 || mon->owner == op)
2118#endif
2119 && (QUERY_FLAG (mon, FLAG_UNAGGRESSIVE) || QUERY_FLAG (mon, FLAG_FRIENDLY))) 2109 && (QUERY_FLAG (mon, FLAG_UNAGGRESSIVE) || QUERY_FLAG (mon, FLAG_FRIENDLY)))
2120 { 2110 {
2121 /* If we're braced, we don't want to switch places with it */ 2111 /* If we're braced, we don't want to switch places with it */
2122 if (op->contr->braced) 2112 if (op->contr->braced)
2123 return; 2113 return false;
2114
2115 if (op->speed_left > 0.f)
2116 {
2117 --op->speed_left;
2124 2118
2125 play_sound_map (op->map, op->x, op->y, SOUND_PUSH_PLAYER); 2119 play_sound_map (op->map, op->x, op->y, SOUND_PUSH_PLAYER);
2126 push_ob (mon, dir, op); 2120 push_ob (mon, dir, op);
2121
2127 if (op->contr->tmp_invis || op->hide) 2122 if (op->contr->tmp_invis || op->hide)
2128 make_visible (op); 2123 make_visible (op);
2129 2124
2130 return; 2125 return true;
2131 } 2126 }
2127 else
2128 return false;
2129 }
2132 2130
2133 /* in certain circumstances, you shouldn't attack friendly 2131 /* in certain circumstances, you shouldn't attack friendly
2134 * creatures. Note that if you are braced, you can't push 2132 * creatures. Note that if you are braced, you can't push
2135 * someone, but put it inside this loop so that you won't 2133 * someone, but put it inside this loop so that you won't
2136 * attack them either. 2134 * attack them either.
2137 */ 2135 */
2138 if ((mon->type == PLAYER || mon->enemy != op) && 2136 if ((mon->type == PLAYER || mon->enemy != op)
2139 (mon->type == PLAYER || QUERY_FLAG (mon, FLAG_UNAGGRESSIVE) || QUERY_FLAG (mon, FLAG_FRIENDLY)) && ( 2137 && (mon->type == PLAYER || QUERY_FLAG (mon, FLAG_UNAGGRESSIVE) || QUERY_FLAG (mon, FLAG_FRIENDLY))
2140#ifdef PROHIBIT_PLAYERKILL
2141 (op->contr->peaceful 2138 && ((op->contr->peaceful
2142 || (mon->type == PLAYER 2139 || (mon->type == PLAYER && mon->contr->peaceful))
2143 && mon->contr->
2144 peaceful)) &&
2145#else
2146 op->contr->peaceful &&
2147#endif
2148 !on_battleground)) 2140 && !on_battleground))
2141 {
2142 if (op->speed_left > 0.f)
2149 { 2143 {
2144 --op->speed_left;
2145
2150 if (!op->contr->braced) 2146 if (!op->contr->braced)
2151 { 2147 {
2152 play_sound_map (op->map, op->x, op->y, SOUND_PUSH_PLAYER); 2148 play_sound_map (op->map, op->x, op->y, SOUND_PUSH_PLAYER);
2153 push_ob (mon, dir, op); 2149 push_ob (mon, dir, op);
2154 } 2150 }
2155 else 2151 else
2156 new_draw_info (0, 0, op, "You withhold your attack"); 2152 new_draw_info (0, 0, op, "You withhold your attack");
2157 2153
2158 if (op->contr->tmp_invis || op->hide) 2154 if (op->contr->tmp_invis || op->hide)
2159 make_visible (op); 2155 make_visible (op);
2160 }
2161 2156
2157 return true;
2158 }
2159 }
2162 /* If the object is a boulder or other rollable object, then 2160 /* If the object is a boulder or other rollable object, then
2163 * roll it if not braced. You can't roll it if you are braced. 2161 * roll it if not braced. You can't roll it if you are braced.
2164 */ 2162 */
2165 else if (QUERY_FLAG (mon, FLAG_CAN_ROLL) && (!op->contr->braced)) 2163 else if (QUERY_FLAG (mon, FLAG_CAN_ROLL) && (!op->contr->braced))
2164 {
2165 if (op->speed_left > 0.f)
2166 { 2166 {
2167 --op->speed_left;
2168
2167 recursive_roll (mon, dir, op); 2169 recursive_roll (mon, dir, op);
2168 if (action_makes_visible (op)) 2170 if (action_makes_visible (op))
2169 make_visible (op); 2171 make_visible (op);
2170 }
2171 2172
2173 return true;
2174 }
2175 }
2172 /* Any generic living creature. Including things like doors. 2176 /* Any generic living creature. Including things like doors.
2173 * Way it works is like this: First, it must have some hit points 2177 * Way it works is like this: First, it must have some hit points
2174 * and be living. Then, it must be one of the following: 2178 * and be living. Then, it must be one of the following:
2175 * 1) Not a player, 2) A player, but of a different party. Note 2179 * 1) Not a player, 2) A player, but of a different party. Note
2176 * that party_number -1 is no party, so attacks can still happen. 2180 * that party_number -1 is no party, so attacks can still happen.
2177 */ 2181 */
2178 else if ((mon->stats.hp >= 0) && QUERY_FLAG (mon, FLAG_ALIVE) && 2182 else if ((mon->stats.hp >= 0) && QUERY_FLAG (mon, FLAG_ALIVE) &&
2179 ((mon->type != PLAYER || op->contr->party == NULL || op->contr->party != mon->contr->party))) 2183 ((mon->type != PLAYER || op->contr->party == NULL || op->contr->party != mon->contr->party)))
2180 { 2184 {
2181 if (!op->contr->has_hit) 2185 if (op->contr->weapon_sp_left > 0.f && !op->flag [FLAG_WIZPASS])
2182 { 2186 {
2183 op->contr->has_hit = 1; 2187 --op->contr->weapon_sp_left;
2184 op->speed_left += op->contr->weapon_speed () - op->speed;
2185 }
2186 2188
2187 skill_attack (mon, op, 0, 0, 0); 2189 skill_attack (mon, op, 0, 0, 0);
2188
2189 /* If attacking another player, that player gets automatic
2190 * hitback, and doesn't loose luck either.
2191 * Disable hitback on the battleground or if the target is
2192 * the wiz.
2193 */
2194 if (mon->type == PLAYER && mon->stats.hp >= 0 && !mon->contr->has_hit && !on_battleground && !QUERY_FLAG (mon, FLAG_WIZ))
2195 {
2196 short luck = mon->stats.luck;
2197
2198 mon->contr->has_hit = 1;
2199 skill_attack (op, mon, 0, 0, 0);
2200 mon->stats.luck = luck;
2201 }
2202 2190
2203 if (action_makes_visible (op)) 2191 if (action_makes_visible (op))
2204 make_visible (op); 2192 make_visible (op);
2205 }
2206 } /* if player should attack something */
2207}
2208 2193
2209int 2194 return true;
2195 }
2196 }
2197
2198 return false;
2199}
2200
2201bool
2210move_player (object *op, int dir) 2202move_player (object *op, int dir)
2211{ 2203{
2212 int pick; 2204 int pick;
2213 2205
2214 if (!op->map || op->map->in_memory != MAP_IN_MEMORY) 2206 if (!op->map || op->map->in_memory != MAP_IN_MEMORY)
… …
2228 op->facing = dir; 2220 op->facing = dir;
2229 2221
2230 if (op->hide) 2222 if (op->hide)
2231 do_hidden_move (op); 2223 do_hidden_move (op);
2232 2224
2225 bool retval;
2226
2233 if (INVOKE_PLAYER (MOVE, op->contr, ARG_INT (dir))) 2227 if (INVOKE_PLAYER (MOVE, op->contr, ARG_INT (dir)))
2234 /*nop */ ; 2228 retval = RESULT_INT (0);
2235 else if (op->contr->fire_on) 2229 else if (op->contr->fire_on)
2236 fire (op, dir); 2230 retval = fire (op, dir);
2237 else 2231 else
2238 { 2232 {
2239 move_player_attack (op, dir); 2233 retval = move_player_attack (op, dir);
2240 pick = check_pick (op); 2234 pick = check_pick (op);
2241 } 2235 }
2242 2236
2243 /* Add special check for newcs players and fire on - this way, the 2237 /* Add special check for newcs players and fire on - this way, the
2244 * server can handle repeat firing. 2238 * server can handle repeat firing.
… …
2251 /* Update how the player looks. Use the facing, so direction may 2245 /* Update how the player looks. Use the facing, so direction may
2252 * get reset to zero. This allows for full animation capabilities 2246 * get reset to zero. This allows for full animation capabilities
2253 * for players. 2247 * for players.
2254 */ 2248 */
2255 animate_object (op, op->facing); 2249 animate_object (op, op->facing);
2256 return 0; 2250
2251 return retval;
2257} 2252}
2258 2253
2259/* This is similar to handle_player, below, but is only used by the 2254/* This is similar to handle_player, below, but is only used by the
2260 * new client/server stuff. 2255 * new client/server stuff.
2261 * This is sort of special, in that the new client/server actually uses 2256 * This is sort of special, in that the new client/server actually uses
2262 * the new speed values for commands. 2257 * the new speed values for commands.
2263 * 2258 *
2264 * Returns true if there are more actions we can do. 2259 * Returns true if there are more actions we can do. Should not do
2260 * many actions in a row, as that would be too unfair to other
2261 * players.
2265 */ 2262 */
2266int 2263bool
2267handle_newcs_player (object *op) 2264handle_newcs_player (object *op)
2268{ 2265{
2269 if (QUERY_FLAG (op, FLAG_SCARED)) 2266 if (QUERY_FLAG (op, FLAG_SCARED))
2270 { 2267 {
2271 flee_player (op); 2268 if (op->speed_left > 0.f)
2272
2273 /* If player is still scared, that is his action for this tick */
2274 if (op->flag [FLAG_SCARED])
2275 { 2269 {
2276 --op->speed_left; 2270 --op->speed_left;
2271 flee_player (op);
2272
2277 return 0; 2273 return true;
2278 } 2274 }
2275 else
2276 return false;
2279 } 2277 }
2280 2278
2281 /* call this here - we also will call this in do_ericserver, but 2279 /* call this here - we also will call this in do_ericserver, but
2282 * the players time has been increased when doericserver has been 2280 * the players time has been increased when doericserver has been
2283 * called, so we recheck it here. 2281 * called, so we recheck it here.
2284 */ 2282 */
2285 if (op->contr->ns->handle_command ()) 2283 if (op->contr->ns->handle_command ())
2286 return 1; 2284 return true;
2287 2285
2288 if (op->speed_left > 0.f)
2289 {
2290 if (op->direction && (op->contr->run_on || op->contr->fire_on)) 2286 if (op->direction && (op->contr->run_on || op->contr->fire_on))
2291 {
2292 /* All move commands take 1 tick, at least for now */
2293 --op->speed_left;
2294
2295 /* Instead of all the stuff below, let move_player take care
2296 * of it. Also, some of the skill stuff is only put in
2297 * there, as well as the confusion stuff.
2298 */
2299 move_player (op, op->direction); 2287 return move_player (op, op->direction);
2300 2288
2301 return op->speed_left > 0.f;
2302 }
2303 }
2304
2305 return 0; 2289 return false;
2306} 2290}
2307 2291
2308int 2292int
2309save_life (object *op) 2293save_life (object *op)
2310{ 2294{
… …
2576 } 2560 }
2577 2561
2578 /* Digestion */ 2562 /* Digestion */
2579 if (--op->last_eat < 0) 2563 if (--op->last_eat < 0)
2580 { 2564 {
2581#ifdef COZY_SERVER
2582 int dg = op->contr->digestion >= 0 && op->contr->digestion < 2 ? 2 : op->contr->digestion;
2583 int bonus = dg > 0 ? dg : 0, penalty = dg < 0 ? -dg : 0;
2584#else
2585 int bonus = op->contr->digestion > 0 ? op->contr->digestion : 0, penalty = op->contr->digestion < 0 ? -op->contr->digestion : 0; 2565 int bonus = op->contr->digestion > 0 ? op->contr->digestion : 0, penalty = op->contr->digestion < 0 ? -op->contr->digestion : 0;
2586#endif
2587 2566
2588 if (op->contr->gen_hp > 0) 2567 if (op->contr->gen_hp > 0)
2589 op->last_eat = 25 * (1 + bonus) / (op->contr->gen_hp + penalty + 1); 2568 op->last_eat = 25 * (1 + bonus) / (op->contr->gen_hp + penalty + 1);
2590 else 2569 else
2591 op->last_eat = 25 * (1 + bonus) / (penalty + 1); 2570 op->last_eat = 25 * (1 + bonus) / (penalty + 1);
… …
3122/* For Hidden creatures - a chance of becoming 'unhidden' 3101/* For Hidden creatures - a chance of becoming 'unhidden'
3123 * every time they move - as we subtract off 'invisibility' 3102 * every time they move - as we subtract off 'invisibility'
3124 * AND, for players, if they move into a ridiculously unhideable 3103 * AND, for players, if they move into a ridiculously unhideable
3125 * spot (surrounded by clear terrain in broad daylight). -b.t. 3104 * spot (surrounded by clear terrain in broad daylight). -b.t.
3126 */ 3105 */
3127
3128void 3106void
3129do_hidden_move (object *op) 3107do_hidden_move (object *op)
3130{ 3108{
3131 int hide = 0, num = random_roll (0, 19, op, PREFER_LOW); 3109 int hide = 0, num = random_roll (0, 19, op, PREFER_LOW);
3132 object *skop; 3110 object *skop;

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines