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

Diff Legend

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