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.141 by root, Fri May 18 15:05:09 2007 UTC vs.
Revision 1.142 by root, Fri May 18 19:46:22 2007 UTC

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

Diff Legend

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