class Nametag2d(Nametag, Clickable2d, MarginVisible):
CONTENTS_SCALE = 0.25
CHAT_TEXT_MAX_ROWS = 6
CHAT_TEXT_WORD_WRAP = 8
CHAT_BALLOON_ALPHA = 0.5
ARROW_OFFSET = -1.0
ARROW_SCALE = 1.5
def __init__(self):
Nametag.__init__(self)
Clickable2d.__init__(self, 'Nametag2d')
MarginVisible.__init__(self)
self.actualChatText = ''
self.arrow = None
self.textNodePath = None
self.contents.setScale(self.CONTENTS_SCALE)
self.hideThought()
#self.cTag = CNametag()
self.accept('MarginVisible-update', self.update)
def destroy(self):
self.ignoreAll()
Nametag.destroy(self)
self.cTag = None
if self.textNodePath is not None:
self.textNodePath.removeNode()
self.textNodePath = None
if self.arrow is not None:
self.arrow.removeNode()
self.arrow = None
Clickable2d.destroy(self)
def getUniqueName(self):
return 'Nametag2d-' + str(id(self))
def getChatBalloonModel(self):
return NametagGlobals.chatBalloon2dModel
def getChatBalloonWidth(self):
return NametagGlobals.chatBalloon2dWidth
def getChatBalloonHeight(self):
return NametagGlobals.chatBalloon2dHeight
def setChatText(self, chatText):
self.actualChatText = chatText
Nametag.setChatText(self, chatText)
def updateClickRegion(self):
if self.chatBalloon is not None:
right = self.chatBalloon.width / 2.0
left = -right
top = self.chatBalloon.height / 2.0
bottom = -top
self.setClickRegionFrame(left, right, bottom, top)
self.region.setActive(True)
elif self.panel is not None:
centerX = (self.textNode.getLeft() +
self.textNode.getRight()) / 2.0
centerY = (self.textNode.getBottom() +
self.textNode.getTop()) / 2.0
left = centerX - (self.panelWidth / 2.0)
right = centerX + (self.panelWidth / 2.0)
bottom = centerY - (self.panelHeight / 2.0)
top = centerY + (self.panelHeight / 2.0)
self.setClickRegionFrame(left, right, bottom, top)
self.region.setActive(True)
else:
if self.region is not None:
self.region.setActive(False)
def isClickable(self):
if self.getChatText() and self.hasChatButton():
return True
return NametagGlobals.wantActiveNametags and Clickable2d.isClickable(
self)
def setClickState(self, clickState):
if self.isClickable():
self.applyClickState(clickState)
else:
self.applyClickState(PGButton.SInactive)
Clickable2d.setClickState(self, clickState)
def enterDepressed(self):
if self.isClickable():
base.playSfx(NametagGlobals.clickSound)
def enterRollover(self):
if self.isClickable() and (self.lastClickState != PGButton.SDepressed):
base.playSfx(NametagGlobals.rolloverSound)
def update(self):
self.contents.node().removeAllChildren()
Nametag.update(self)
if self.cell is not None:
# We're in the margin display. Reposition our content, and update
# the click region:
self.reposition()
if self.isClickable():
self.updateClickRegion()
else:
# We aren't in the margin display. Disable the click region if one
# is present:
if self.region is not None:
self.region.setActive(False)
def tick(self, task):
if (self.avatar is None) or self.avatar.isEmpty():
return Task.cont
if (self.cell is None) or (self.arrow is None):
return Task.cont
location = self.avatar.getPos(NametagGlobals.me)
rotation = NametagGlobals.me.getQuat(base.cam)
camSpacePos = rotation.xform(location)
arrowRadians = math.atan2(camSpacePos[0], camSpacePos[1])
arrowDegrees = (arrowRadians / math.pi) * 180
self.arrow.setR(arrowDegrees - 90)
return Task.cont
def drawChatBalloon(self, model, modelWidth, modelHeight):
if self.chatFont is None:
# We can't draw this without a font.
return
# Prefix the nametag text:
if hasattr(self.avatar, 'avatarType'
) and self.avatar.avatarType == CIGlobals.Suit and len(
self.getText().split('\n')) == 3:
# Just show the cog's name
name, _, _ = self.getText().split('\n')
else:
name = self.getText()
self.chatTextNode.setText(name + ': ' + self.actualChatText)
# Set our priority in the margin system:
self.setPriority(MarginGlobals.MP_normal)
if self.textNodePath is not None:
self.textNodePath.removeNode()
self.textNodePath = None
if self.arrow is not None:
self.arrow.removeNode()
self.arrow = None
if self.isClickable():
foreground, background = self.chatColor[self.clickState]
else:
foreground, background = self.chatColor[PGButton.SInactive]
if self.chatType == NametagGlobals.SPEEDCHAT:
background = self.speedChatColor
if background[3] > self.CHAT_BALLOON_ALPHA:
background = VBase4(background[0], background[1], background[2],
self.CHAT_BALLOON_ALPHA)
self.chatBalloon = ChatBalloon(model,
modelWidth,
modelHeight,
self.chatTextNode,
foreground=foreground,
background=background,
reversed=self.chatReversed,
button=self.chatButton[self.clickState],
is2d=True)
self.chatBalloon.reparentTo(self.contents)
#self.cTag.set_chatballoon_size(self.chatBalloon.width, self.chatBalloon.height)
# Calculate the center of the TextNode:
left, right, bottom, top = self.chatTextNode.getFrameActual()
center = self.contents.getRelativePoint(self.chatBalloon.textNodePath,
((left + right) / 2.0, 0,
(bottom + top) / 2.0))
# Translate the chat balloon along the inverse:
self.chatBalloon.setPos(self.chatBalloon, -center)
def drawNametag(self):
# Set our priority in the margin system:
self.setPriority(MarginGlobals.MP_low)
if self.textNodePath is not None:
self.textNodePath.removeNode()
self.textNodePath = None
if self.arrow is not None:
self.arrow.removeNode()
self.arrow = None
if self.font is None:
# We can't draw this without a font.
return
# Attach the icon:
if self.icon is not None:
self.contents.attachNewNode(self.icon)
if self.isClickable():
foreground, background = self.nametagColor[self.clickState]
else:
foreground, background = self.nametagColor[PGButton.SInactive]
# Set the color of the TextNode:
self.textNode.setTextColor(foreground)
# Attach the TextNode:
self.textNodePath = self.contents.attachNewNode(
self.textNode.generate(), 1)
self.textNodePath.setTransparency(foreground[3] < 1)
self.textNodePath.setAttrib(DepthWriteAttrib.make(0))
self.textNodePath.setY(self.TEXT_Y_OFFSET)
# Attach a panel behind the TextNode:
self.panel = NametagGlobals.cardModel.copyTo(self.contents, 0)
self.panel.setColor(background)
self.panel.setTransparency(background[3] < 1)
# Reposition the panel:
x = (self.textNode.getLeft() + self.textNode.getRight()) / 2.0
z = (self.textNode.getBottom() + self.textNode.getTop()) / 2.0
self.panel.setPos(x, 0, z)
# Resize the panel:
self.panelWidth = self.textNode.getWidth() + self.PANEL_X_PADDING
self.panelHeight = self.textNode.getHeight() + self.PANEL_Z_PADDING
self.panel.setScale(self.panelWidth, 1, self.panelHeight)
#self.cTag.set_panel_size(self.panelWidth, self.panelHeight)
# Add an arrow:
self.arrow = NametagGlobals.arrowModel.copyTo(self.contents)
self.arrow.setZ(self.ARROW_OFFSET + self.textNode.getBottom())
self.arrow.setScale(self.ARROW_SCALE)
self.arrow.setColor(
NametagGlobals.NametagColors[NametagGlobals.CCOtherPlayer][0][0])
#self.arrow.setShaderOff(1)
def marginVisibilityChanged(self):
if self.cell is not None:
# We're in the margin display. Reposition our content, and update
# the click region:
self.reposition()
self.updateClickRegion()
else:
# We aren't in the margin display. Disable the click region if one
# is present:
if self.region is not None:
self.region.setActive(False)
def reposition(self):
if self.contents is None:
return
origin = Point3()
self.contents.setPos(origin)
if self.chatBalloon is not None:
self.chatBalloon.removeNode()
self.chatBalloon = None
self.contents.node().removeAllChildren()
if (self.cell in base.leftCells) or (self.cell in base.rightCells):
text = self.getChatText().replace('\x01WLDisplay\x01',
'').replace('\x02', '')
textWidth = self.chatTextNode.calcWidth(text)
if (textWidth /
self.CHAT_TEXT_WORD_WRAP) > self.CHAT_TEXT_MAX_ROWS:
self.chatTextNode.setWordwrap(
textWidth / (self.CHAT_TEXT_MAX_ROWS - 0.5))
else:
self.chatTextNode.setWordwrap(self.CHAT_TEXT_WORD_WRAP)
model = self.getChatBalloonModel()
modelWidth = self.getChatBalloonWidth()
modelHeight = self.getChatBalloonHeight()
self.drawChatBalloon(model, modelWidth, modelHeight)
nodePath = self.chatBalloon.textNodePath
left, right, bottom, top = self.chatTextNode.getFrameActual()
elif self.panel is not None:
nodePath = self.textNodePath
left, right, bottom, top = self.textNode.getFrameActual()
# Compensate for the arrow:
bottom -= self.ARROW_SCALE
else:
return
if self.cell in base.bottomCells:
# Move the origin to the bottom center of the node path:
origin = self.contents.getRelativePoint(
nodePath, ((left + right) / 2.0, 0, bottom))
elif self.cell in base.leftCells:
# Move the origin to the left center of the node path:
origin = self.contents.getRelativePoint(nodePath,
(left, 0,
(bottom + top) / 2.0))
elif self.cell in base.rightCells:
# Move the origin to the right center of the node path:
origin = self.contents.getRelativePoint(nodePath,
(right, 0,
(bottom + top) / 2.0))
self.contents.setPos(self.contents, -origin)
class WhisperPopup(Clickable2d, MarginVisible):
CONTENTS_SCALE = 0.25
TEXT_MAX_ROWS = 6
TEXT_WORD_WRAP = 8
QUIT_BUTTON_SHIFT = (0.42, 0, 0.42)
WHISPER_TIMEOUT_MIN = 10
WHISPER_TIMEOUT_MAX = 20
def __init__(self, text, font, whisperType, timeout=None):
Clickable2d.__init__(self, 'WhisperPopup')
MarginVisible.__init__(self)
self.text = text
self.font = font
self.whisperType = whisperType
if timeout is None:
self.timeout = len(text) * 0.33
if self.timeout < self.WHISPER_TIMEOUT_MIN:
self.timeout = self.WHISPER_TIMEOUT_MIN
elif self.timeout > self.WHISPER_TIMEOUT_MAX:
self.timeout = self.WHISPER_TIMEOUT_MAX
else:
self.timeout = timeout
self.active = False
self.senderName = ''
self.fromId = 0
self.isPlayer = 0
self.contents.setScale(self.CONTENTS_SCALE)
self.whisperColor = ChatGlobals.WhisperColors[self.whisperType]
self.textNode = TextNode('text')
self.textNode.setWordwrap(self.TEXT_WORD_WRAP)
self.textNode.setTextColor(self.whisperColor[PGButton.SInactive][0])
self.textNode.setFont(self.font)
self.textNode.setText(self.text)
self.chatBalloon = None
self.quitButton = None
self.timeoutTaskName = self.getUniqueName() + '-timeout'
self.timeoutTask = None
self.quitEvent = self.getUniqueName() + '-quit'
self.accept(self.quitEvent, self.destroy)
self.setPriority(MarginGlobals.MP_high)
self.setVisible(True)
self.update()
self.accept('MarginVisible-update', self.update)
def destroy(self):
self.ignoreAll()
if self.timeoutTask is not None:
taskMgr.remove(self.timeoutTask)
self.timeoutTask = None
if self.chatBalloon is not None:
self.chatBalloon.removeNode()
self.chatBalloon = None
if self.quitButton is not None:
self.quitButton.destroy()
self.quitButton = None
self.textNode = None
Clickable2d.destroy(self)
def getUniqueName(self):
return 'WhisperPopup-' + str(id(self))
def update(self):
if self.chatBalloon is not None:
self.chatBalloon.removeNode()
self.chatBalloon = None
if self.quitButton is not None:
self.quitButton.destroy()
self.quitButton = None
self.contents.node().removeAllChildren()
self.draw()
if self.cell is not None:
# We're in the margin display. Reposition our content, and update
# the click region:
self.reposition()
self.updateClickRegion()
else:
# We aren't in the margin display. Disable the click region if one
# is present:
if self.region is not None:
self.region.setActive(False)
def draw(self):
if self.isClickable():
foreground, background = self.whisperColor[self.clickState]
else:
foreground, background = self.whisperColor[PGButton.SInactive]
self.chatBalloon = ChatBalloon(
NametagGlobals.chatBalloon2dModel,
NametagGlobals.chatBalloon2dWidth,
NametagGlobals.chatBalloon2dHeight, self.textNode,
foreground=foreground, background=background,
is2d=True
)
self.chatBalloon.reparentTo(self.contents)
# Calculate the center of the TextNode:
left, right, bottom, top = self.textNode.getFrameActual()
center = self.contents.getRelativePoint(
self.chatBalloon.textNodePath,
((left+right) / 2.0, 0, (bottom+top) / 2.0))
# Translate the chat balloon along the inverse:
self.chatBalloon.setPos(self.chatBalloon, -center)
# Draw the quit button:
self.quitButton = WhisperQuitButton(self)
quitButtonNodePath = self.contents.attachNewNode(self.quitButton)
# Move the quit button to the top right of the TextNode:
quitButtonNodePath.setPos(self.contents.getRelativePoint(
self.chatBalloon.textNodePath, (right, 0, top)))
# Apply the quit button shift:
quitButtonNodePath.setPos(quitButtonNodePath, self.QUIT_BUTTON_SHIFT)
# Allow the quit button to close this whisper:
self.quitButton.setClickEvent(self.quitEvent)
def manage(self, marginManager):
MarginVisible.manage(self, marginManager)
base.playSfx(base.cr.whisperNoise)
self.timeoutTask = taskMgr.doMethodLater(
self.timeout, self.unmanage, self.timeoutTaskName, [marginManager])
def unmanage(self, marginManager):
MarginVisible.unmanage(self, marginManager)
self.destroy()
def setClickable(self, senderName, fromId, isPlayer=0):
self.senderName = senderName
self.fromId = fromId
self.isPlayer = isPlayer
self.setClickEvent('clickedWhisper', extraArgs=[senderName, fromId, isPlayer])
self.setActive(True)
def applyClickState(self, clickState):
if self.chatBalloon is not None:
foreground, background = self.whisperColor[clickState]
self.chatBalloon.setForeground(foreground)
self.chatBalloon.setBackground(background)
def setClickState(self, clickState):
if self.isClickable():
self.applyClickState(clickState)
else:
self.applyClickState(PGButton.SInactive)
if self.isHovering() or self.quitButton.isHovering():
self.quitButton.contents.show()
elif self.quitButton.getClickState() == PGButton.SDepressed:
self.quitButton.contents.show()
else:
self.quitButton.contents.hide()
Clickable2d.setClickState(self, clickState)
def enterDepressed(self):
if self.isClickable():
base.playSfx(NametagGlobals.clickSound)
def enterRollover(self):
if self.isClickable() and (self.lastClickState != PGButton.SDepressed):
base.playSfx(NametagGlobals.rolloverSound)
def updateClickRegion(self):
if self.chatBalloon is not None:
right = self.chatBalloon.width / 2.0
left = -right
top = self.chatBalloon.height / 2.0
bottom = -top
self.setClickRegionFrame(left, right, bottom, top)
self.region.setActive(True)
else:
if self.region is not None:
self.region.setActive(False)
if self.quitButton is not None:
self.quitButton.updateClickRegion()
def marginVisibilityChanged(self):
if self.cell is not None:
# We're in the margin display. Reposition our content, and update
# the click region:
self.reposition()
self.updateClickRegion()
else:
# We aren't in the margin display. Disable the click region if one
# is present:
if self.region is not None:
self.region.setActive(False)
def reposition(self):
if self.contents is None:
return
origin = Point3()
self.contents.setPos(origin)
if self.chatBalloon is not None:
self.chatBalloon.removeNode()
self.chatBalloon = None
if self.quitButton is not None:
self.quitButton.destroy()
self.quitButton = None
self.contents.node().removeAllChildren()
if (self.cell in base.leftCells) or (self.cell in base.rightCells):
text = self.text.replace('\x01WLDisplay\x01', '').replace('\x02', '')
textWidth = self.textNode.calcWidth(text)
if (textWidth / self.TEXT_WORD_WRAP) > self.TEXT_MAX_ROWS:
self.textNode.setWordwrap(textWidth / (self.TEXT_MAX_ROWS-0.5))
else:
self.textNode.setWordwrap(self.TEXT_WORD_WRAP)
self.draw()
left, right, bottom, top = self.textNode.getFrameActual()
if self.cell in base.bottomCells:
# Move the origin to the bottom center of the chat balloon:
origin = self.contents.getRelativePoint(
self.chatBalloon.textNodePath, ((left+right) / 2.0, 0, bottom))
elif self.cell in base.leftCells:
# Move the origin to the left center of the chat balloon:
origin = self.contents.getRelativePoint(
self.chatBalloon.textNodePath, (left, 0, (bottom+top) / 2.0))
elif self.cell in base.rightCells:
# Move the origin to the right center of the chat balloon:
origin = self.contents.getRelativePoint(
self.chatBalloon.textNodePath, (right, 0, (bottom+top) / 2.0))
self.contents.setPos(self.contents, -origin)
class ToonTalker:
THOUGHT_PREFIX = '.'
LENGTH_FACTOR = 0.6
MIN_LENGTH = 5
MAX_LENGTH = 20
def __init__(self):
self.avatar = None
self.nametag = None
self.autoClearChat = True
def setAutoClearChat(self, flag):
self.autoClearChat = flag
def setAvatar(self, avatar, nametag):
self.avatar = avatar
self.nametag = nametag
def setChatAbsolute(self, chatString=None):
if not chatString or chatString.isspace() or len(chatString) == 0:
return
self.clearChat()
self.taskId = random.randint(0, 1000000000000000000000000000000)
if self.nameTag:
self.getNameTag().hide()
if self.isThought(chatString):
chatString = self.removeThoughtPrefix(chatString)
bubble = loader.loadModel(CIGlobals.ThoughtBubble)
else:
length = math.sqrt(len(chatString)) / self.LENGTH_FACTOR
if length < self.MIN_LENGTH:
length = self.MIN_LENGTH
if length > self.MAX_LENGTH:
length = self.MAX_LENGTH
bubble = loader.loadModel(CIGlobals.ChatBubble)
if self.autoClearChat:
taskMgr.doMethodLater(
length, self.clearChatTask,
"clearAvatarChat-%s" % (str(self.taskId)))
if self.avatarType == CIGlobals.Suit:
font = CIGlobals.getSuitFont()
else:
font = CIGlobals.getToonFont()
self.chatBubble = ChatBalloon(bubble).generate(chatString, font)
self.chatBubble.setEffect(
BillboardEffect.make(Vec3(0, 0, 1), True, False, 3.0, camera,
Point3(0, 0, 0)))
if self.nameTag:
self.chatBubble.setZ(self.getNameTag().getZ())
else:
if self.avatarType == CIGlobals.Suit:
nametagZ = self.suitPlan.getNametagZ()
self.chatBubble.setZ(nametagZ)
if self.avatar and hasattr(self.avatar, 'getGhost'):
if not self.avatar.getGhost(
) or self.avatar.doId == base.localAvatar.doId:
self.chatBubble.reparentTo(self)
else:
self.chatBubble.reparentTo(self)
LabelScaler().resize(self.chatBubble)
def isThought(self, message):
if message.isspace() or len(message) == 0:
return False
if message[0] == self.THOUGHT_PREFIX and not CIGlobals.isNPCToon(self):
return True
else:
return False
def removeThoughtPrefix(self, message):
if self.isThought(message):
return message[len(self.THOUGHT_PREFIX):]
else:
notify.warning(
"attempted to remove a thought prefix on a non-thought message"
)
return message
def clearChatTask(self, task):
self.clearChat()
return task.done
def clearChat(self):
try:
self.chatBubble.removeNode()
del self.chatBubble
except:
return
if self.avatar and hasattr(self.avatar, 'getGhost'):
if self.nameTag and not self.avatar.getGhost(
) or self.nameTag and self.avatar.doId == base.localAvatar.doId:
self.getNameTag().show()
else:
if self.nameTag:
self.getNameTag().show()
taskMgr.remove("clearAvatarChat-" + str(self.taskId))