Python wolfpack.finditem函数代码示例

def poisonit( char, args ):
	potion = wolfpack.finditem(args[ 0 ])
	item = wolfpack.finditem(args[ 1 ])
	if not potion or not item:
		return

	skill = char.skill[ POISONING ]

	# poison strength : lesser(0), normal, greater, deadly(3)
	strength = int( potion.getintproperty( 'potiontype' ) ) - 14

	# consume the potion / add a blank bottle
	potions.consumePotion(char, potion, True)

	if not char.checkskill( POISONING, MINSKILLS[strength], MAXSKILLS[strength] ):
		char.socket.clilocmessage( 1010518 )
		return 1

	char.socket.clilocmessage(1010517)

	# decrease karma / fame

	# set poisoning infos as tags
	item.settag( 'poisoning_char', char.serial )
	item.settag( 'poisoning_strength', strength )
	item.settag( 'poisoning_skill', skill )
	# weapon : poison chance when hit % = char.skill[ POISONING ] / 4
	# 	number of uses before the poison wears off
	if item.hasscript( 'blades' ):
		item.settag( 'poisoning_uses', 18 - strength * 2 )
	return 1

def chainpotiontimer( cserial, iserial, bserial, outradius ):
	char = wolfpack.findchar( cserial )
	item = wolfpack.finditem( iserial )
	bomb = wolfpack.finditem( bserial )

	if not item or not bomb:
		return False

	if bomb.hastag( 'exploding' ):
		return False

	# Doing error checks first, makes it faster
	if not checkLoS( item, bomb, outradius ):
		return False

	potiontype = getPotionType( bomb )

	if not potiontype in [11, 12, 13]:
		return False

	bomb.settag( 'exploding', cserial )

	if isPotionkeg( bomb ) and int( bomb.gettag( 'kegfill' ) ) >= 1:
		bomb.addtimer( randint( 1000, 2250 ), "potions.explosion.potioncountdown", [ char.serial, 10, int( bomb.gettag( 'kegfill' ) ) ] )
	else:
		bomb.addtimer( randint( 1000, 2250 ), "potions.explosion.potioncountdown", [ char.serial, 0, bomb.amount ] )
	return True

def create_leaves(serial, fruittype="apple"):
    object = wolfpack.finditem(serial)
    # Lets figure out what kind of leaves we need
    if object.id == 0xD94:
        leaves = wolfpack.additem("d95")
    elif object.id == 0xD98:
        leaves = wolfpack.additem("d99")

    if leaves:
        object.settag("leaf_serial", leaves.serial)
        leaves = None
        leaves = wolfpack.finditem(object.gettag("leaf_serial"))
        leaves.pos = "%i,%i,%i,%i" % (object.pos.x, object.pos.y, object.pos.z, object.pos.map)
        if leaves.pos != object.pos:
            leaves.moveto(object.pos)
            # leaves.visible = 0
        object.update()
        # 2 - 15 minutes
        leaves.addtimer(int(60000 * random.randint(2, 15)), leaves_progress, [])
        leaves.update()
        leaves.settag("fruit_count", 0)
        leaves.settag("fruit_type", str(fruittype))
        leaves.settag("stage", 0)
        return True
    else:
        object.update()
        return False

def response( char, args, target ):

	direction = char.directionto( target.pos )
	if not char.direction == direction:
		char.direction = direction
		char.update()
	item = wolfpack.finditem( args[0] )

	if ( ( char.pos.x-target.pos.x )**2 + ( char.pos.y-target.pos.y )**2 > 4):
		char.socket.clilocmessage( 502648, '', GRAY) # You are too far away to do that.
		return True

	if abs( char.pos.z - target.pos.z ) > 5:
		char.socket.clilocmessage( 502648, '', GRAY) # You are too far away to do that.
		return True

	# Check target (only item targets valid)
	if not target.item:
		char.socket.clilocmessage( 502658, '', GRAY ) # Use that on a spinning wheel.
		return True

	if target.item.id in ids:
		color = item.color
		if ( item.amount > 1 ):
			item.amount = item.amount -1
			item.update()
		else:
			item.delete()

		# Spinning Wheel Animations
		if target.item.id == ids[0]:
			target.item.id = animids[0]
			target.item.update()
		elif target.item.id == ids[1]:
			target.item.id = animids[1]
			target.item.update()
		elif target.item.id == ids[2]:
			target.item.id = animids[2]
			target.item.update()
		elif target.item.id == ids[3]:
			target.item.id = animids[3]
			target.item.update()

		wheel = wolfpack.finditem( target.item.serial )
		processtime = 5000 # 5 Seconds
		char.addtimer( processtime, ProcessTimer, [wheel.serial, color] )

	elif target.item.id in animids:
		# That spinning wheel is being used.
		char.socket.clilocmessage( 502656, '', GRAY )
		return True

	else:
		# Use that on a spinning wheel.
		char.socket.clilocmessage( 502658, '', GRAY )
		return True

	def smelt(self, player, arguments, target):
		if not self.checktool(player, wolfpack.finditem(arguments[0])):
			return False

		tool = wolfpack.finditem(arguments[0])
		if tool == target.item:
			player.socket.clilocmessage(1044271)
			return

		# Smelt a weapon
		item = target.item
		weapon = itemcheck(item, ITEM_WEAPON)
		shield = itemcheck(item, ITEM_SHIELD)
		armor = itemcheck(item, ITEM_ARMOR)

		# See if it's in our ore list.
		if weapon or shield or armor:
			if item.container != player.getbackpack():
				player.socket.clilocmessage(1044274)
				return

			if item.hastag('resname'):
				resname = str(item.gettag('resname'))
			else:
				resname = None

			for metal in METALS:
				if metal[5] == resname:
					# Try to find out how many ingots this item would need
					action = self.topmostmenu().findcraftitem(item.baseid)
					returned = 0.25 + min(1000, player.skill[MINING]) / 2000

					if action and action.submaterial1 > 0:
						amount = int(math.floor(action.submaterial1 * returned))
					else:
						amount = 1

					if amount > 0:
						# Randomly select one of the resources required by that metal
						item.delete()
						ingots = wolfpack.additem(random.choice(metal[3]))
						ingots.amount = amount
						if not tobackpack(ingots, player):
							ingots.update()

						player.soundeffect(0x2a)
						player.soundeffect(0x240)

						player.socket.clilocmessage(1044270)
						self.send(player, arguments)
						return

		player.socket.clilocmessage(1044272)
		self.send(player, arguments)

def response(player, arguments, response):
	if response.button == 0:
		return

	command = (response.button >> 28) & 0xC
	item = wolfpack.finditem((response.button & 0x3FFFFFFF) | 0x40000000)
	target = item.container
	
	# Delete Item
	if command == 0x04:
		player.log(LOG_MESSAGE, 'Deleting item 0x%x from character 0x%x.\n' % (item.serial, item.container.serial))
		item.delete()
		
		showEditGump(player, target)

	# Bounce Item
	elif command == 0x08:
		player.log(LOG_MESSAGE, 'Bouncing item 0x%x from character 0x%x.\n' % (item.serial, item.container.serial))
		
		if not tobackpack(item, player):			
			item.update()
			
		showEditGump(player, target)

	# Show Info For Item
	elif command == 0x0C:
		player.log(LOG_MESSAGE, 'Showing info gump for item 0x%x from character 0x%x.\n' % (item.serial, item.container.serial))
		iteminfo(player.socket, item)

	else:
		player.socket.sysmessage('Unknown command.')

def response_receiver( char, args, target ):
	item = wolfpack.finditem( args[0] )
	if not item:
		return False
	if not item.getoutmostchar() == char and not char.canreach( target.pos, 2 ):
		char.socket.clilocmessage( 1019045 ) # I can't reach that.
		return False

	if target.item and target.item.serial == item.serial:
		if active(item):
			deactivate( item )
			char.socket.clilocmessage( 500672 ) # You turn the crystal off.
		else:
			activate_receiver( item )
			char.socket.clilocmessage( 500673 ) # You turn the crystal on.

	elif target.char:
		if item.hastag( "sender" ):
			deltags_sender( item )
			item.deltag( "sender" )
			char.socket.clilocmessage( 1010044 ) # You unlink the receiver crystal.
		else:
			char.socket.clilocmessage( 1010045 ) # That receiver crystal is not linked.

	else:
		if getname(target.item.baseid) in recharges.keys():
			char.socket.clilocmessage( 500677 ) # This crystal cannot be recharged.
			return True
		char.socket.clilocmessage( 1010045 ) # That receiver crystal is not linked.
	return True

def placement(player, arguments, target):
	deed = wolfpack.finditem(arguments[0])
	(dispid, xoffset, yoffset, zoffset) = arguments[1:] # Get the rest of the arguments
	
	if not checkDeed(player, deed):
		return	

	if not player.canreach(target.pos, 20):
		player.socket.sysmessage('You can\'t reach that.')
		return
		
	(canplace, moveout) = wolfpack.canplace(target.pos, dispid - 0x4000, 4)
	
	if not canplace:
		player.socket.sysmessage('CANT PLACE THERE')
		return
	
	house = wolfpack.addmulti(str(deed.gettag('section')))
	house.owner = player
	house.moveto(target.pos)
	house.update()
	housing.registerHouse(house)

	for obj in moveout:
		obj.removefromview()
		obj.moveto(player.pos)
		obj.update()
		if obj.ischar() and obj.socket:
			obj.socket.resendworld()

def provocation( char, skill ):
	socket = char.socket

	if not char.socket:
		return False
	# Only handle provocation
	if skill != PROVOCATION:
		return False

	if not socket.hastag( 'instrument' ):
		socket.clilocmessage( 0x7A74E, '', 0x3b2, 3 ) # What instrument shall I play music on?
		socket.attachtarget( "skills.provocation.findinstrument" )
		return True

	instserial = socket.gettag( 'instrument' )
	instrument = wolfpack.finditem( instserial )
	backpack = char.getbackpack()

	if not instrument or not instrument.getoutmostitem() == backpack:
		socket.clilocmessage( 0x7A74E, "", 0x3b2, 3 ) # What instrument shall I play music on?
		socket.attachtarget( "skills.provocation.findinstrument" )
		return True

	socket.clilocmessage( 0x7A74D, "", 0x3b2, 3 ) # What do you wish to incite?
	socket.attachtarget( "skills.provocation.response1", [instrument] )
	return True

def placement(player, arguments, target):
	deed = wolfpack.finditem(arguments[0])
	(dispid, xoffset, yoffset, zoffset) = arguments[1:] # Get the rest of the arguments

	if not checkDeed(player, deed):
		return	

        region = wolfpack.region( target.pos.x, target.pos.y, target.map )
        if region.cave:
		player.socket.clilocmessage( 502488 ) # You can not place a ship inside a dungeon.
		return
                
	(canplace, moveout) = wolfpack.canplaceboat(target.pos, dispid - 0x4000)

	if not canplace or player.pos.distance( target.pos ) > 30:
		player.socket.clilocmessage( 1043284 ) # A ship can not be created here.
		return

        createBoat( player, deed, target.pos )
	deed.delete()

	for obj in moveout:
		obj.removefromview()
		obj.moveto(player.pos)
		obj.update()
		if obj.ischar() and obj.socket:
			obj.socket.resendworld()
	return

def dyingtub_response( char, args, target ):
	dyetub = wolfpack.finditem( args[0] )

	if not dyetub or not char.canreach( dyetub, 2 ):
		char.message( localemsg( 6 ) )
		return

	if not target.item:
		char.message( localemsg( 8 ) )
		return

	# Valid Target?
	if not char.gm:
		if target.item.getoutmostchar() != char:
			char.socket.sysmessage( localemsg( 10 ) )
			return

		if not target.item.dye:
			char.socket.sysmessage( localemsg( 11 ) )
			return

	char.log( LOG_MESSAGE, "Dying item (%x,%x) using tub (%x,%x)\n" % ( target.item.serial, target.item.color, dyetub.serial, dyetub.color ) )
	target.item.color = dyetub.color
	target.item.update()
	char.soundeffect(0x023e)

def selecttarget( char, args, target ):
	# you cannot use skill while dead
	if char.dead:
		char.socket.clilocmessage( 502796 )
		return

	potion = wolfpack.finditem(args[ 0 ])
	if not potion:
		return

	if not target.item:
		char.socket.clilocmessage( 502145 )
		return

	global ALLOWED
	if not target.item.id in ALLOWED and not target.item.hasscript('food') and not target.item.hasscript('beverage'):
		char.socket.clilocmessage(1060204)
		return

	if skills.skilltable[ POISONING ][ skills.UNHIDE ] and char.hidden:
		char.reveal()

	# sound / effect
	char.soundeffect( 0x4F )
	# apply poison to the item
	char.addtimer( POISONING_DELAY, poisonit, [ potion.serial, target.item.serial ] )
	return 1

def lock_response(char, args, target):
  if len(args) != 1:
    return

  key = wolfpack.finditem(args[0])
  if not key or not char.canreach(key,5):
    char.socket.clilocmessage(501661)
    return

  # Check for an item target.
  if not target.item or not char.canreach(target.item,5):
    char.socket.clilocmessage(501666)
    return

  if target.item == key:
    rename_key(char,key)

  elif target.item.hasscript( 'lock' ):
    if target.item.hastag('locked') and int(target.item.gettag('locked')) == 1:
      target.item.deltag('locked')
    else:
      target.item.settag('locked',1)
    char.soundeffect(0x241)

  else:
    char.socket.clilocmessage(501666)

  return

	def applyproperties(self, player, arguments, item, exceptional):
		# All tailoring items crafted out of leather gain the special color
		if self.submaterial1 > 0:
			material = self.parent.getsubmaterial1used(player, arguments)
			material = self.parent.submaterials1[material]
			item.color = material[4]
			item.settag('resname', material[5])

		# Distribute another 6 points randomly between the resistances an armor alread
		# has. There are no tailored weapons.
		if exceptional:
			if itemcheck(item, ITEM_ARMOR) or itemcheck(item, ITEM_SHIELD):
				# Copy all the values to tags
				boni = [0, 0, 0, 0, 0]

				for i in range(0, 6):
					boni[random.randint(0,4)] += 1

				item.settag('res_physical', fromitem(item, RESISTANCE_PHYSICAL) + boni[0])
				item.settag('res_fire', fromitem(item, RESISTANCE_FIRE) + boni[1])
				item.settag('res_cold', fromitem(item, RESISTANCE_COLD) + boni[2])
				item.settag('res_energy', fromitem(item, RESISTANCE_ENERGY) + boni[3])
				item.settag('res_poison', fromitem(item, RESISTANCE_POISON) + boni[4])

		# Reduce the uses remain count
		checktool(player, wolfpack.finditem(arguments[0]), 1)

def response(player, arguments, response):
	if response.button == 0:
		return

	item = wolfpack.finditem(arguments[0])
	if not item:
		return

	# Validate parameters
	if not 0 in response.switches and not 1 in response.switches:
		player.socket.sysmessage('You have to choose a spawntype.')
		return

	spawntype = response.switches[0]

	try:
		definition = response.text[0]
		area = int(response.text[1])
		mininterval = int(response.text[2])
		maxinterval = int(response.text[3])
	except:
		player.socket.sysmessage('You entered an invalid value.')
		return

	item.settag('spawntype', spawntype)
	item.settag('spawndef', definition)
	item.settag('area', area)
	item.settag('mininterval', mininterval)
	item.settag('maxinterval', maxinterval)

	item.resendtooltip()