Python wolfpack.findchar函数代码示例

	def check(self):
		toremove = []
		for page in self.pages:
			char = wolfpack.findchar(page.serial)
			if not char:
				toremove.append(page)
				continue
			if page.assigned:
				char = wolfpack.findchar(page.assigned)
				if not char or not char.socket:
					page.assigned = None
					continue
		for page in toremove:
			self.remove(page)

	def add(self, page, notify = True):
		updated = False
		if page in self.pages:
			updated = True
			self.pages.remove(page)
		self.pages.append(page)
		self.save()

		if notify:
			char = wolfpack.findchar(page.serial)
			if char:
				if updated:
					char.log(LOG_MESSAGE, "%s (%s) updates his gm page [%s]:\n%s\n" % (char.name, page.account, page.category, "\n".join(page.message)))					
				else:					
					char.log(LOG_MESSAGE, "%s (%s) makes a gm page [%s]:\n%s\n" % (char.name, page.account, page.category, "\n".join(page.message)))
		
			notification = page.notification(updated)
			socket = wolfpack.sockets.first()
			while socket:
				player = socket.player
				
				# If the pagenotify flag is on and it is a staff account,
				# send a notification about the new or updated page.
				if player and player.rank > 1 and player.account.flags & 0x10 != 0:				
					# Send the notification to the socket
					socket.sysmessage(notification, 0x846)
					
					for line in page.message:
						if len(line) > 0:
							socket.sysmessage(line, 0x843)

				socket = wolfpack.sockets.next()

def pages_gump(player):
	global pages
	pages.check() # Make sure all pages are valid
	
	gump = wolfpack.gumps.cGump()
	
	gump.startPage(0)
	
	# Gump Background
	gump.addBackground( 0xE10, 480, 360 ) # Background
	gump.addCheckerTrans( 15, 15, 450, 330 )
	
	# Gump Header
	gump.addGump( 180, 18, 0xFA8 )
	gump.addText( 215, 20, "Page Queue", 0x530 )

	# Close Button
	gump.addText( 70, 320, "Close", 0x834 )
	gump.addButton( 30, 320, 0xFB1, 0xFB3, 0 )

	count = (pages.count() + 9) / 10

	# Iterate this loop once for every page	
	for i in range(0, count):
		gump.startPage(i + 1)
		offset = 0

		for j in range(i * 10, i * 10 + 10):
			if j < pages.count():
				page = pages.pages[j]
				pagetype = page.type()

				if not page.assigned:
					gump.addButton( 20, 60 + offset, 0xFA5, 0xFA7, 1 + j )

				char = wolfpack.findchar(page.serial)

				if char.socket:
					gump.addText( 55, 60 + offset, "%s (%s)" % (char.name, page.account), 0x844 + 5 * pagetype )
					gump.addText( 200, 60 + offset, page.category, 0x844 + 5 * pagetype )
					gump.addText( 280, 60 + offset, time.strftime(FORMAT_DATETIME, time.localtime(page.created)), 0x844 + 5 * pagetype )
				else:
					gump.addText( 55, 60 + offset, "%s (%s)" % (char.name, page.account), 2100 )
					gump.addText( 200, 60 + offset, page.category, 2100 )
					gump.addText( 280, 60 + offset, time.strftime(FORMAT_DATETIME, time.localtime(page.created)), 21000 )
					
				offset += 20
				
		gump.addText( 280, 320, "Page %u of %u" % ( i + 1, count ), 0x834 )

		# Are we on the first page
		if i > 0:
			gump.addPageButton( 240, 320, 0x0FC, 0x0FC, i - 1 )

		# Would the next page be valid?
		if i + 1 < count:
			gump.addPageButton( 260, 320, 0x0FA, 0x0FA, i + 2 )

	gump.setCallback("system.pages.pages_gump_response")
	gump.send(player.socket)

def onUse(player, item):
	if not item.getoutmostchar() == player:
		player.socket.sysmessage('The figurine needs to be in your posession to use it.')
		return 1

	if not item.hastag('pet'):
		item.delete()
		return 1

	try:
		pet = wolfpack.findchar(int(item.gettag('pet')))

		if not pet:
			item.deltag('pet')
			item.delete()
			return 1
	except:
		item.deltag('pet')
		item.delete()
		return 1

	# Remove pet reference and then delete
	item.deltag('pet')
	item.delete()

	pet.stablemaster = -1
	pet.moveto(player.pos)
	pet.update()
	pet.sound(SND_IDLE)
	pet.action(ANIM_CASTDIRECTED)
	return 1

def onTrade( player, type, buttonstate, itemserial ):
	#Receiving button state, close request etc...
	#itemserial == tradecontainer.serial of player
	#buttonstate == 1 : user confirm deal
	#buttonstate == 0 : user reject deal
	#type == 1 : user want to close trade
	#type == 2 : button pressed
	handler = { 1 : closetrade, 2 : pressbutton }

	#Check if we have a partner
	if player.hastag( 'trade_partner' ):
		partner = wolfpack.findchar( player.gettag( 'trade_partner' ) )
		if not partner:
			return True
	else:
		return True

	#Get tradecontainers
	box2 = partner.itemonlayer( LAYER_TRADING )
	box1 = player.itemonlayer( LAYER_TRADING )

	#Something lost ?
	if not box1 or not box2:
		closetrade( player, partner, box1, box2 )

	#Button pressed ?
	if buttonstate == 1:
		player.settag( 'trade_button', 1 )

	#Execute handler of specified type
	handler[type]( player, partner, box1, box2 )


	return True

def onPickup(player1, item):
	box1 = player1.itemonlayer(LAYER_TRADING)
	if not box1:
		return False

	if item.container != box1:
		return False

	if not player1.hastag('trade_partner'):
		return False

	player2 = wolfpack.findchar(int(player1.gettag('trade_partner')))
	if not player2:
		return False
	box2 = player2.itemonlayer(LAYER_TRADING)

	if not box2:
		return False

	player1.settag( 'trade_button', 0 )
	player2.settag( 'trade_button', 0 )

	# Reset the trading status and resend it
	# To me
	sendtradepacket( player1.socket, 2, box1.serial, 0, 0, "" )

	# To partner
	sendtradepacket( player2.socket, 2, box2.serial, 0, 0, "" )

	item.removefromview(True)

	return False

def attack_target(char, arguments, target):
    if not target.char or target.char == char:
        char.socket.sysmessage(tr("Your pets cannot attack that."))
        return

    (pet, all) = arguments
    if all:
        if char.gm:
            pos = char.pos
            pets = wolfpack.chars(pos.x, pos.y, pos.map, 18, False)
            for follower in pets:
                if follower.npc and not follower.frozen:
                    attack_target(char, [follower.serial, False], target)
        else:
            for follower in char.followers:
                attack_target(char, [follower.serial, False], target)
    else:
        pet = wolfpack.findchar(pet)
        if target.char == pet:
            char.socket.sysmessage(tr("Your pet refuses to kill itself."))
            return
        if pet and (pet.owner == char or char.gm) and pet.distanceto(char) < 18:
            startfight(pet, target.char)
            pet.fight(target.char)

            # right here we need to not interrupt the target, but i can't register a fight unless i do, right? not sure.
            target.char.fight(pet)
            target.char.follow(pet)

            go_target(char, arguments, target)
            follow_target(char, arguments, target)
            pet.sound(SND_ATTACK)

def endheal(char, arguments):
	socket = char.socket

	if not socket:
		return # Cancel healing if the player disconnected

	if char.dead:
		socket.clilocmessage(500962) # Died before finishing his work
		socket.deltag('bandage_slipped')
		return

	if socket.hastag('bandage_slipped'):
		slipped = int(socket.gettag('bandage_slipped')) # How many times the fingers slipped
	else:
		slipped = 0
	socket.deltag('bandage_slipped')

	# Retrieve arguments
	(primary, secondary, target) = arguments
	target = wolfpack.findchar(target)

	# Sanity checks again
	if not target or not char.canreach(target, 2):
		socket.clilocmessage(500963) # You did not stay close enough
		return

	if target.dead:
		resurrectTarget(char, target, primary, secondary, slipped) # Resurrection attempt
	elif target.poison != -1:
		cureTarget(char, target, primary, secondary, slipped) # Cure attempt
	elif system.bleeding.isbleeding(target):
		system.bleeding.end(target)
	else:
		healTarget(char, target, primary, secondary, slipped) # Heal attempt

def stroke(player, arguments):
	(source, count) = arguments

	if player.dead or player.pos.map == 0xff:
		end(player, False) # End bleeding if dead, but dont message
	else:
		amount = random.randint(count, count * 2)
		if player.npc:
			amount *= 2

		player.soundeffect(0x133)
		player.damage(DAMAGE_GODLY, amount, wolfpack.findchar(source)) 

		if player.pos.map != 0xff:
			blood = wolfpack.additem(random.choice(BLOOD))
			blood.movable = 3 # Not movable
			blood.decay = True # Make it decay
			blood.moveto(player.pos)
			blood.update()

	# There are still strokes left	
	if count > 1 and not player.dead and player.pos.map != 0xff:
		player.addtimer(TIMERINTERVAL, stroke, [source, count - 1], False, False, TIMERID)
	else:
		end(player)

def gump11(char, callback, item):
    # security remove a co owner
    gump_params = ["a house", "sign"]

    mygump = cGump()
    mygump.addRawLayout("{page 0}")
    mygump.addRawLayout("{resizepic 0 0 5054 420 440}")
    mygump.addRawLayout("{gumppictiled 10 10 400 100 2624}")
    mygump.addRawLayout("{checkertrans 10 10 400 100}")
    mygump.addRawLayout("{gumppictiled 10 120 400 260 2624}")
    mygump.addRawLayout("{checkertrans 10 120 400 260}")
    mygump.addRawLayout("{gumppictiled 10 390 400 40 2624}")
    mygump.addRawLayout("{checkertrans 10 390 400 40}")
    mygump.addRawLayout("{button 250 410 4005 4007 1 0 0}")
    mygump.addRawLayout("{xmfhtmlgumpcolor 285 410 240 20 1060675 0 0 32767}")
    mygump.addRawLayout("{gumppic 10 10 100}")
    mygump.addRawLayout("{text 62 43 0 0}")
    mygump.addRawLayout("{text 74 57 0 1}")
    # remove button cause change of callback
    # ~ mygump.addRawLayout( "{button 10 390 4005 4007 1 0 31}" )
    mygump.addRawLayout("{xmfhtmlgumpcolor 45 390 240 20 1060676 0 0 32767}")
    # ~ mygump.addRawLayout( "{button 10 410 4005 4007 1 0 46}" )
    mygump.addRawLayout("{xmfhtmlgumpcolor 45 410 240 20 1060677 0 0 32767}")
    # ~ mygump.addRawLayout( "{button 150 10 4005 4007 1 0 2}" )
    mygump.addRawLayout("{xmfhtmlgumpcolor 195 10 200 20 1060668 0 0 32767}")
    # ~ mygump.addRawLayout( "{button 150 30 4006 4007 1 0 17}" )
    mygump.addRawLayout("{xmfhtmlgumpcolor 195 30 200 20 1060669 0 0 16927}")
    # ~ mygump.addRawLayout( "{button 150 50 4005 4007 1 0 32}" )
    mygump.addRawLayout("{xmfhtmlgumpcolor 195 50 200 20 1060670 0 0 32767}")
    # ~ mygump.addRawLayout( "{button 150 70 4005 4007 1 0 47}" )
    mygump.addRawLayout("{xmfhtmlgumpcolor 195 70 200 20 1060671 0 0 32767}")
    # ~ mygump.addRawLayout( "{button 150 90 4005 4007 1 0 62}" )
    mygump.addRawLayout("{xmfhtmlgumpcolor 195 90 200 20 1060672 0 0 32767}")  # end of common part with gump0
    # mygump.addRawLayout( "{button 10 130 4005 4007 1 0 4}" ) # button see title next line
    mygump.addRawLayout("{xmfhtmlgumpcolor 45 130 240 20 1011274 0 0 32767}")  # View Remove a co-owner from the house
    # ~ mygump.addRawLayout( "{text 45 170 1152 2}" )#~ mygump.addRawLayout( "{text 45 150 1152 2}" ) #ecrit le parametre 2 en blanc

    offsetx = 0
    offsety = 0
    members = getCoOwners(item.multi)
    # ~ char.socket.sysmessage('liste %s'%members)
    for memberserial in members:
        try:
            member = wolfpack.findchar(int(memberserial))
            mygump.addButton(15 + offsety, 150 + offsetx, 0xFA5, 0xFA7, member.serial)
            # ~ mygump.addText( 15 +offsety, 150+offsetx, unicode(' *'), 1152)
            mygump.addText(49 + offsety, 150 + offsetx, unicode(member.name), 1152)
            if offsetx == 192:
                offsetx = 0
                offsety += 200
            else:
                offsetx += 24
        except:
            pass
    mygump.setCallback(callbackremovecoowner)
    mygump.setArgs([item])
    # Add params
    for line in gump_params:
        mygump.addRawText(line)
    mygump.send(char)

def gump_response(char, arguments, response):
	vendor = wolfpack.findchar(arguments[0])
	if not vendor or vendor.distanceto(char) > 4:
		return

	if response.button == 0:
		return

	if response.button > len(sellList):		
		return

	item = sellList[response.button - 1]

	female = ( char.id in PLAYER_BODIES_ALIVE_FEMALE )
	gold = char.getbackpack().countitems(['eed'])
	gold += char.getbankbox().countitems(['eed'])
		
	# Check if we can afford it
	if female and item[2]:
		vendor.say(1010639, "", "", False, vendor.saycolor, char.socket)
		return

	if item[1] > gold and not char.gm:
		vendor.say(1042293, "", "", False, vendor.saycolor, char.socket)
		return

	item[3](vendor, char, item, item[4])

def onUse(player, item):
	if not item.getoutmostchar() == player:
		player.socket.sysmessage(tr('The figurine needs to be in your posession to use it.'))
		return 1

	if not item.hastag('pet'):
		item.delete()
		return 1

	try:
		pet = wolfpack.findchar(int(item.gettag('pet')))

		if not pet:
			item.deltag('pet')
			item.delete()
			return 1
	except:
		item.deltag('pet')
		item.delete()
		return 1

	# Remove pet reference and then delete
	item.deltag('pet')
	item.delete()

	pet.removescript('figurine')
	pet.owner = player
	pet.stablemaster = 0
	pet.wandertype = 0 # Stay where you are...
	pet.direction = player.direction
	pet.moveto(player.pos)
	pet.update()
	pet.sound(SND_IDLE)
	pet.action(ANIM_CASTDIRECTED)
	return 1

def sendresponse2(player, arguments, target):
    if target.item:
        if target.item.container:
            return
        else:
            pos = target.item.pos
    elif target.char:
        pos = target.char.pos
    else:
        pos = target.pos

    if arguments[0] >= 0x40000000:
        object = wolfpack.finditem(arguments[0])
    else:
        object = wolfpack.findchar(arguments[0])

    if not object:
        return
    object.removefromview()
    object.moveto(pos)
    object.update()
    if not object.ischar() or not object.socket:
        return
    object.socket.resendworld()
    return

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

	target = wolfpack.findchar(arguments[0])

	if not target:
		return False

	# Iterate trough all skills and see what changed
	for skill in range( 0, ALLSKILLS ):
		try:
			newvalue = int(floor(float(response.text[0x1000 | skill]) * 10))
			newcap = int(floor(float(response.text[0x2000 | skill]) * 10))
		except:
			player.socket.sysmessage('You have entered invalid values for %s.' % SKILLNAMES[skill])
			return False

		oldvalue = target.skill[skill]
		oldcap = target.skillcap[skill]

		if oldvalue != newvalue or oldcap != newcap:
			message = "Changed %s for character 0x%x to value %u [%d] and cap %u [%d].\n"
			message = message % (SKILLNAMES[skill], target.serial, newvalue, newvalue - oldvalue, newcap, newcap - oldcap)
			player.log(LOG_MESSAGE, message)
			player.socket.sysmessage(message)

			target.skill[skill] = newvalue
			target.skillcap[skill] = newcap

def onLogin(player):
  if player.hastag('guildmessages'):
    count = int(player.gettag('guildmessages'))

    for i in range(0, count):
      name = 'guildmessage' + str(i)
      text = unicode(player.gettag(name))
      player.socket.sysmessage(text, 0x3A)
      player.deltag(name)
    player.deltag('guildmessages')

  # Make sure that this event is removed as soon as we don't are in a guild anymore
  if not player.guild:
    # Clean voting and or permissions
    tags = player.tags
    for tag in tags:
      if tag.startswith('vote_'):
        player.deltag(tag)
      elif tag.startswith('permissions_'):
        player.deltag(tag)

    player.removescript( 'guilds.member' )
  else:
    # Remove voting tags just in case
    if player.guild.leader:
      player.deltag('vote_%u' % player.guild.serial)

    members = player.guild.members
    online = []

    for member in members:
      if member != player and member.socket:
        online.append(member)

    if len(online) > 1:
      player.socket.sysmessage('There are %u other members of your guild logged on.' % len(online), 0x30)
    elif len(online) == 1:
      player.socket.sysmessage('There is one other member of your guild logged on.', 0x30)
    else:
      player.socket.sysmessage('There is no other member of your guild logged on.', 0x30)

    # Private messaging
    tags = player.tags

    for tag in tags:
      if tag.startswith('privmsg'):
        serial = int(tag[7:])
        char = wolfpack.findchar(serial)
        if char:
          chunks = getPrivateMessage(player, char)
          time_now = localtime()
          time_message = localtime(chunks[0])

          # Hide the date if it's from the same day
          if time_now[0] != time_message[0] or time_now[1] != time_message[1] or time_now[2] != time_message[2]:
            player.socket.sysmessage('[%s] %s: %s' % (strftime(FORMAT_DATETIME, time_message), char.name, chunks[2]), chunks[1])
          else:
            player.socket.sysmessage('[%s] %s: %s' % (strftime(FORMAT_TIME, time_message), char.name, chunks[2]), chunks[1])

        player.deltag(tag)