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.139 by root, Fri May 18 01:01:02 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;
… …
272 266
273 for (object *op = ob->inv; op; op = op->below) 267 for (object *op = ob->inv; op; op = op->below)
274 if (op->flag [FLAG_APPLIED]) 268 if (op->flag [FLAG_APPLIED])
275 switch (op->type) 269 switch (op->type)
276 { 270 {
271 case SKILL:
272 ob->flag [FLAG_APPLIED] = false;
273 break;
274
277 case WAND: 275 case WAND:
278 case ROD: 276 case ROD:
279 case HORN: 277 case HORN:
280 case BOW: 278 case BOW:
281 case SKILL_TOOL: 279 ranged_ob = op;
280 break;
281
282 case WEAPON: 282 case WEAPON:
283 op->flag [FLAG_APPLIED] = false; 283 combat_ob = op;
284 apply_special (ob, op, AP_APPLY);
285 break;
286
287 case SKILL:
288 op->flag [FLAG_APPLIED] = false;
289 break; 284 break;
290 } 285 }
291 286
292 ob->change_weapon (combat_ob ? combat_ob : ranged_ob); 287 ob->change_weapon (combat_ob ? combat_ob : ranged_ob);
293 ob->update_stats (); 288 ob->update_stats ();
… …
333player::set_object (object *op) 328player::set_object (object *op)
334{ 329{
335 ob = op; 330 ob = op;
336 ob->contr = this; /* this aren't yet in archetype */ 331 ob->contr = this; /* this aren't yet in archetype */
337 332
338 ob->speed_left = 0.5f;
339 ob->speed = 1.0f; 333 ob->speed = 1.0f;
334 ob->speed_left = 0.5f;
335
340 ob->direction = 5; /* So player faces south */ 336 ob->direction = 5; /* So player faces south */
341} 337}
342 338
343player::player () 339player::player ()
344{ 340{
345 /* There are some elements we want initialised to non zero value - 341 /* There are some elements we want initialised to non zero value -
… …
356 petmode = pet_normal; 352 petmode = pet_normal;
357 listening = 10; 353 listening = 10;
358 usekeys = containers; 354 usekeys = containers;
359 peaceful = 1; /* default peaceful */ 355 peaceful = 1; /* default peaceful */
360 do_los = 1; 356 do_los = 1;
357
358 weapon_sp = 1.0f;
359 weapon_sp_left = 0.5f;
361} 360}
362 361
363void 362void
364player::do_destroy () 363player::do_destroy ()
365{ 364{
… …
1640 arrow->stats.grace = arrow->attacktype; 1639 arrow->stats.grace = arrow->attacktype;
1641 1640
1642 if (arrow->slaying) 1641 if (arrow->slaying)
1643 arrow->spellarg = strdup (arrow->slaying); 1642 arrow->spellarg = strdup (arrow->slaying);
1644 1643
1644#if 0
1645 if (player *pl = op->contr) 1645 if (player *pl = op->contr)
1646 { 1646 {
1647 if (!pl->has_hit)
1648 {
1649 pl->has_hit = 1;
1650 pl->ob->speed_left += pl->weapon_speed () - pl->ob->speed;
1651 }
1652#if 0
1653 float speed = pl->weapon_sp; 1647 float speed = pl->weapon_sp;
1654 1648
1655 /* penalize ROF for bestarrow */ 1649 /* penalize ROF for bestarrow */
1656 if (pl->bowtype == bow_bestarrow) 1650 if (pl->bowtype == bow_bestarrow)
1657 speed *= .9f; 1651 speed *= .9f;
1658 else 1652 else
1659 speed *= 1.f + dex_bonus[op->stats.Dex] * .2f; 1653 speed *= 1.f + dex_bonus[op->stats.Dex] * .2f;
1660 1654
1661 op->speed_left += speed - op->speed; 1655 op->speed_left += speed - op->speed;
1656 }
1662#endif 1657#endif
1663 }
1664 1658
1665 SET_ANIMATION (arrow, arrow->direction); 1659 SET_ANIMATION (arrow, arrow->direction);
1666 1660
1667 /* update the speed */ 1661 /* update the speed */
1668 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
1669 + bow->stats.dam / 7.0; 1663 + bow->stats.dam / 7.f;
1670 1664
1671 arrow->set_speed (max (arrow->speed, 2.0)); 1665 arrow->set_speed (max (arrow->speed, 2.f));
1672 arrow->speed_left = 0; 1666 arrow->speed_left = 0;
1673 1667
1674 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;
1675 1669
1676 if (op->type == PLAYER) 1670 if (op->type == PLAYER)
… …
1835 } 1829 }
1836} 1830}
1837 1831
1838/* Received a fire command for the player - go and do it. 1832/* Received a fire command for the player - go and do it.
1839 */ 1833 */
1840void 1834bool
1841fire (object *op, int dir) 1835fire (object *op, int dir)
1842{ 1836{
1843 int spellcost = 0; 1837 int spellcost = 0;
1844 1838
1845 /* check for loss of invisiblity/hide */ 1839 /* check for loss of invisiblity/hide */
… …
1849 player *pl = op->contr; 1843 player *pl = op->contr;
1850 1844
1851 if (pl->golem) 1845 if (pl->golem)
1852 { 1846 {
1853 control_golem (op->contr->golem, dir); 1847 control_golem (op->contr->golem, dir);
1854 return; 1848 return false;
1855 } 1849 }
1856 1850
1857 object *ob = pl->ranged_ob; 1851 object *ob = pl->ranged_ob;
1858 1852
1859 if (!ob) 1853 if (!ob)
1860 return; 1854 return false;
1861 1855
1862 if (!op->change_weapon (ob)) 1856 if (!op->change_weapon (ob))
1863 return; 1857 return false;
1858
1859 if (op->speed_left > 0.f)
1860 --op->speed_left;
1861 else
1862 return false;
1864 1863
1865 switch (ob->type) 1864 switch (ob->type)
1866 { 1865 {
1867 case BOW: 1866 case BOW:
1868 player_fire_bow (op, dir); 1867 player_fire_bow (op, dir);
… …
1882 1881
1883 default: 1882 default:
1884 fire_misc_object (op, dir); 1883 fire_misc_object (op, dir);
1885 break; 1884 break;
1886 } 1885 }
1886
1887 return true;
1887} 1888}
1888 1889
1889/* find_key 1890/* find_key
1890 * 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
1891 * and successfully use it, we return the key, otherwise NULL 1892 * and successfully use it, we return the key, otherwise NULL
… …
1978 * 0 otherwise 1979 * 0 otherwise
1979 */ 1980 */
1980static int 1981static int
1981player_attack_door (object *op, object *door) 1982player_attack_door (object *op, object *door)
1982{ 1983{
1983 /* 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,
1984 * 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 -
1985 * otherwise, we fall through to the rest of the code. 1986 * otherwise, we fall through to the rest of the code.
1986 */ 1987 */
1987 object *key = find_key (op, op, door); 1988 object *key = find_key (op, op, door);
1988 1989
1989 /* IF we found a key, do some extra work */ 1990 /* If we found a key, do some extra work */
1990 if (key) 1991 if (key)
1991 { 1992 {
1992 object *container = key->env; 1993 object *container = key->env;
1993 1994
1994 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);
… …
2029 * It should keep the code cleaner. 2030 * It should keep the code cleaner.
2030 * When this is called, the players direction has been updated 2031 * When this is called, the players direction has been updated
2031 * (taking into account confusion.) The player is also actually 2032 * (taking into account confusion.) The player is also actually
2032 * going to try and move (not fire weapons). 2033 * going to try and move (not fire weapons).
2033 */ 2034 */
2034void 2035bool
2035move_player_attack (object *op, int dir) 2036move_player_attack (object *op, int dir)
2036{ 2037{
2037 object *tmp, *mon;
2038 int on_battleground; 2038 int on_battleground;
2039 maptile *m;
2040 2039
2041 sint16 nx = freearr_x[dir] + op->x; 2040 sint16 nx = freearr_x[dir] + op->x;
2042 sint16 ny = freearr_y[dir] + op->y; 2041 sint16 ny = freearr_y[dir] + op->y;
2043 2042
2044 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 }
2045 2053
2046 /* 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
2047 * 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
2048 * 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
2049 * player. This is a pretty nasty hack, because if we could 2057 * player. This is a pretty nasty hack, because if we could
2050 * 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
2051 * 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
2052 * 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
2053 * move_ob uses. 2061 * move_ob uses.
2054 */ 2062 */
2055 if ((op->contr->braced || !move_ob (op, dir, op)) && !out_of_map (op->map, nx, ny))
2056 {
2057 if (OUT_OF_REAL_MAP (op->map, nx, ny))
2058 {
2059 m = op->map->xy_find (nx, ny); 2063 maptile *m = op->map->xy_find (nx, ny);
2060 if (!m)
2061 return; /* Don't think this should happen */
2062 }
2063 else
2064 m = op->map;
2065 2064
2066 if (!(tmp = m->at (nx, ny).bot))
2067 return;
2068
2069 mon = 0;
2070 /* 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
2071 * 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.
2072 * 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
2073 * on the space 2068 * on the space
2074 */ 2069 */
2075 while (tmp) 2070 object *mon;
2076 { 2071 for (mon = m->at (nx, ny).bot; mon; mon = mon->above)
2077 if (tmp == op) 2072 {
2078 { 2073 if ((mon->flag [FLAG_ALIVE]
2079 tmp = tmp->above; 2074 || mon->type == LOCKED_DOOR
2080 continue; 2075 || mon->flag [FLAG_CAN_ROLL])
2081 }
2082
2083 if (QUERY_FLAG (tmp, FLAG_ALIVE))
2084 {
2085 mon = tmp; 2076 && mon != op)
2086 break; 2077 break;
2087 } 2078 }
2088 2079
2089 if (tmp->type == LOCKED_DOOR || QUERY_FLAG (tmp, FLAG_CAN_ROLL))
2090 mon = tmp;
2091
2092 tmp = tmp->above;
2093 }
2094
2095 if (!mon) /* This happens anytime the player tries to move */ 2080 if (!mon) /* This happens anytime the player tries to move */
2096 return; /* into a wall */ 2081 return false; /* into a wall */
2097 2082
2098 if (mon->head)
2099 mon = mon->head; 2083 mon = mon->head_ ();
2100 2084
2101 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)
2102 if (player_attack_door (op, mon)) 2087 if (player_attack_door (op, mon))
2088 {
2089 --op->contr->weapon_sp_left;
2103 return; 2090 return true;
2091 }
2104 2092
2105 /* The following deals with possibly attacking peaceful 2093 /* The following deals with possibly attacking peaceful
2106 * or frienddly creatures. Basically, all players are considered 2094 * or friendly creatures. Basically, all players are considered
2107 * unaggressive. If the moving player has peaceful set, then the 2095 * unaggressive. If the moving player has peaceful set, then the
2108 * object should be pushed instead of attacked. It is assumed that 2096 * object should be pushed instead of attacked. It is assumed that
2109 * if you are braced, you will not attack friends accidently, 2097 * if you are braced, you will not attack friends accidently,
2110 * and thus will not push them. 2098 * and thus will not push them.
2111 */ 2099 */
2112 2100
2113 /* 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
2114 * peaceful. Our assumption is the creature is a pet if the 2102 * peaceful. Our assumption is the creature is a pet if the
2115 * player owns it and it is either friendly or unagressive. 2103 * player owns it and it is either friendly or unagressive.
2116 */ 2104 */
2117 if (op->type == PLAYER 2105 if (op->type == PLAYER
2118 && ((mon->owner && mon->owner->contr 2106 && ((mon->owner && mon->owner->contr
2119 && same_party (mon->owner->contr->party, op->contr->party)) 2107 && same_party (mon->owner->contr->party, op->contr->party))
2120 || mon->owner == op) 2108 || mon->owner == op)
2121 && (QUERY_FLAG (mon, FLAG_UNAGGRESSIVE) || QUERY_FLAG (mon, FLAG_FRIENDLY))) 2109 && (QUERY_FLAG (mon, FLAG_UNAGGRESSIVE) || QUERY_FLAG (mon, FLAG_FRIENDLY)))
2122 { 2110 {
2123 /* 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 */
2124 if (op->contr->braced) 2112 if (op->contr->braced)
2125 return; 2113 return false;
2114
2115 if (op->speed_left > 0.f)
2116 {
2117 --op->speed_left;
2126 2118
2127 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);
2128 push_ob (mon, dir, op); 2120 push_ob (mon, dir, op);
2121
2129 if (op->contr->tmp_invis || op->hide) 2122 if (op->contr->tmp_invis || op->hide)
2130 make_visible (op); 2123 make_visible (op);
2131 2124
2132 return; 2125 return true;
2133 } 2126 }
2127 else
2128 return false;
2129 }
2134 2130
2135 /* in certain circumstances, you shouldn't attack friendly 2131 /* in certain circumstances, you shouldn't attack friendly
2136 * creatures. Note that if you are braced, you can't push 2132 * creatures. Note that if you are braced, you can't push
2137 * 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
2138 * attack them either. 2134 * attack them either.
2139 */ 2135 */
2140 if ((mon->type == PLAYER || mon->enemy != op) 2136 if ((mon->type == PLAYER || mon->enemy != op)
2141 && (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))
2142 && ((op->contr->peaceful 2138 && ((op->contr->peaceful
2143 || (mon->type == PLAYER && mon->contr->peaceful)) 2139 || (mon->type == PLAYER && mon->contr->peaceful))
2144 && !on_battleground)) 2140 && !on_battleground))
2141 {
2142 if (op->speed_left > 0.f)
2145 { 2143 {
2144 --op->speed_left;
2145
2146 if (!op->contr->braced) 2146 if (!op->contr->braced)
2147 { 2147 {
2148 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);
2149 push_ob (mon, dir, op); 2149 push_ob (mon, dir, op);
2150 } 2150 }
2151 else 2151 else
2152 new_draw_info (0, 0, op, "You withhold your attack"); 2152 new_draw_info (0, 0, op, "You withhold your attack");
2153 2153
2154 if (op->contr->tmp_invis || op->hide) 2154 if (op->contr->tmp_invis || op->hide)
2155 make_visible (op); 2155 make_visible (op);
2156 }
2157 2156
2157 return true;
2158 }
2159 }
2158 /* If the object is a boulder or other rollable object, then 2160 /* If the object is a boulder or other rollable object, then
2159 * 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.
2160 */ 2162 */
2161 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)
2162 { 2166 {
2167 --op->speed_left;
2168
2163 recursive_roll (mon, dir, op); 2169 recursive_roll (mon, dir, op);
2164 if (action_makes_visible (op)) 2170 if (action_makes_visible (op))
2165 make_visible (op); 2171 make_visible (op);
2166 }
2167 2172
2173 return true;
2174 }
2175 }
2168 /* Any generic living creature. Including things like doors. 2176 /* Any generic living creature. Including things like doors.
2169 * 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
2170 * and be living. Then, it must be one of the following: 2178 * and be living. Then, it must be one of the following:
2171 * 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
2172 * 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.
2173 */ 2181 */
2174 else if ((mon->stats.hp >= 0) && QUERY_FLAG (mon, FLAG_ALIVE) && 2182 else if ((mon->stats.hp >= 0) && QUERY_FLAG (mon, FLAG_ALIVE) &&
2175 ((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)))
2176 { 2184 {
2177 if (!op->contr->has_hit) 2185 if (op->contr->weapon_sp_left > 0.f && !op->flag [FLAG_WIZPASS])
2178 { 2186 {
2179 op->contr->has_hit = 1; 2187 --op->contr->weapon_sp_left;
2180 op->speed_left += op->contr->weapon_speed () - op->speed;
2181 }
2182 2188
2183 skill_attack (mon, op, 0, 0, 0); 2189 skill_attack (mon, op, 0, 0, 0);
2184
2185 /* If attacking another player, that player gets automatic
2186 * hitback, and doesn't loose luck either.
2187 * Disable hitback on the battleground or if the target is
2188 * the wiz.
2189 */
2190 if (mon->type == PLAYER && mon->stats.hp >= 0 && !mon->contr->has_hit && !on_battleground && !QUERY_FLAG (mon, FLAG_WIZ))
2191 {
2192 short luck = mon->stats.luck;
2193
2194 mon->contr->has_hit = 1;
2195 skill_attack (op, mon, 0, 0, 0);
2196 mon->stats.luck = luck;
2197 }
2198 2190
2199 if (action_makes_visible (op)) 2191 if (action_makes_visible (op))
2200 make_visible (op); 2192 make_visible (op);
2201 }
2202 } /* if player should attack something */
2203}
2204 2193
2205int 2194 return true;
2195 }
2196 }
2197
2198 return false;
2199}
2200
2201bool
2206move_player (object *op, int dir) 2202move_player (object *op, int dir)
2207{ 2203{
2208 int pick; 2204 int pick;
2209 2205
2210 if (!op->map || op->map->in_memory != MAP_IN_MEMORY) 2206 if (!op->map || op->map->in_memory != MAP_IN_MEMORY)
… …
2224 op->facing = dir; 2220 op->facing = dir;
2225 2221
2226 if (op->hide) 2222 if (op->hide)
2227 do_hidden_move (op); 2223 do_hidden_move (op);
2228 2224
2225 bool retval;
2226
2229 if (INVOKE_PLAYER (MOVE, op->contr, ARG_INT (dir))) 2227 if (INVOKE_PLAYER (MOVE, op->contr, ARG_INT (dir)))
2230 /*nop */ ; 2228 retval = RESULT_INT (0);
2231 else if (op->contr->fire_on) 2229 else if (op->contr->fire_on)
2232 fire (op, dir); 2230 retval = fire (op, dir);
2233 else 2231 else
2234 { 2232 {
2235 move_player_attack (op, dir); 2233 retval = move_player_attack (op, dir);
2236 pick = check_pick (op); 2234 pick = check_pick (op);
2237 } 2235 }
2238 2236
2239 /* 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
2240 * server can handle repeat firing. 2238 * server can handle repeat firing.
… …
2247 /* Update how the player looks. Use the facing, so direction may 2245 /* Update how the player looks. Use the facing, so direction may
2248 * get reset to zero. This allows for full animation capabilities 2246 * get reset to zero. This allows for full animation capabilities
2249 * for players. 2247 * for players.
2250 */ 2248 */
2251 animate_object (op, op->facing); 2249 animate_object (op, op->facing);
2252 return 0; 2250
2251 return retval;
2253} 2252}
2254 2253
2255/* 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
2256 * new client/server stuff. 2255 * new client/server stuff.
2257 * 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
2258 * the new speed values for commands. 2257 * the new speed values for commands.
2259 * 2258 *
2260 * 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.
2261 */ 2262 */
2262int 2263bool
2263handle_newcs_player (object *op) 2264handle_newcs_player (object *op)
2264{ 2265{
2265 if (QUERY_FLAG (op, FLAG_SCARED)) 2266 if (QUERY_FLAG (op, FLAG_SCARED))
2266 { 2267 {
2267 flee_player (op); 2268 if (op->speed_left > 0.f)
2268
2269 /* If player is still scared, that is his action for this tick */
2270 if (op->flag [FLAG_SCARED])
2271 { 2269 {
2272 --op->speed_left; 2270 --op->speed_left;
2271 flee_player (op);
2272
2273 return 0; 2273 return true;
2274 } 2274 }
2275 else
2276 return false;
2275 } 2277 }
2276 2278
2277 /* 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
2278 * the players time has been increased when doericserver has been 2280 * the players time has been increased when doericserver has been
2279 * called, so we recheck it here. 2281 * called, so we recheck it here.
2280 */ 2282 */
2281 if (op->contr->ns->handle_command ()) 2283 if (op->contr->ns->handle_command ())
2282 return 1; 2284 return true;
2283 2285
2284 if (op->speed_left > 0.f)
2285 {
2286 if (op->direction && (op->contr->run_on || op->contr->fire_on)) 2286 if (op->direction && (op->contr->run_on || op->contr->fire_on))
2287 {
2288 /* All move commands take 1 tick, at least for now */
2289 --op->speed_left;
2290
2291 /* Instead of all the stuff below, let move_player take care
2292 * of it. Also, some of the skill stuff is only put in
2293 * there, as well as the confusion stuff.
2294 */
2295 move_player (op, op->direction); 2287 return move_player (op, op->direction);
2296 2288
2297 return op->speed_left > 0.f;
2298 }
2299 }
2300
2301 return 0; 2289 return false;
2302} 2290}
2303 2291
2304int 2292int
2305save_life (object *op) 2293save_life (object *op)
2306{ 2294{
… …
3113/* For Hidden creatures - a chance of becoming 'unhidden' 3101/* For Hidden creatures - a chance of becoming 'unhidden'
3114 * every time they move - as we subtract off 'invisibility' 3102 * every time they move - as we subtract off 'invisibility'
3115 * AND, for players, if they move into a ridiculously unhideable 3103 * AND, for players, if they move into a ridiculously unhideable
3116 * spot (surrounded by clear terrain in broad daylight). -b.t. 3104 * spot (surrounded by clear terrain in broad daylight). -b.t.
3117 */ 3105 */
3118
3119void 3106void
3120do_hidden_move (object *op) 3107do_hidden_move (object *op)
3121{ 3108{
3122 int hide = 0, num = random_roll (0, 19, op, PREFER_LOW); 3109 int hide = 0, num = random_roll (0, 19, op, PREFER_LOW);
3123 object *skop; 3110 object *skop;

Diff Legend

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