Python RepairMincroGame._initVisuals方法代码示例

# 需要导入模块: from RepairMincroGame import RepairMincroGame [as 别名]
# 或者: from RepairMincroGame.RepairMincroGame import _initVisuals [as 别名]
 def _initVisuals(self):
     RepairMincroGame._initVisuals(self)
     self.model = loader.loadModel('models/gui/pir_m_gui_srp_bracing_main')
     self.background = self.model.find('**/background')
     self.background.reparentTo(self)
     self.background.setZ(0.17499999999999999)
     self.gridParent = self.attachNewNode('gridParent')
     self.grid = []
     for xpos in range(GRID_SIZE):
         col = []
         for ypos in range(GRID_SIZE):
             allWoodSquaresGeom = NodePath('wood_squares')
             for i in range(self.model.find('**/wood_squares').getNumChildren()):
                 self.model.find('**/wood_squares').getChild(i).copyTo(allWoodSquaresGeom)
             
             tempGeom = NodePath('tempGeom')
             self.model.find('**/wood_squares').getChild(0).copyTo(tempGeom)
             selectedOutlineGeom = NodePath('selectedOutlineGeom')
             self.model.find('**/selected').copyTo(selectedOutlineGeom)
             selectedOutlineGeom.setScale(0.90000000000000002)
             piece = RepairGridPiece(name = 'piece%i' % (xpos * GRID_SIZE + ypos), parent = self.gridParent, allWoodSquaresGeom = allWoodSquaresGeom, selectedOutlineGeom = selectedOutlineGeom, scale = (0.90000000000000002, 0.90000000000000002, 0.90000000000000002), pos = (-0.22 + xpos * SPACING, 0.0, -0.029999999999999999 + ypos * SPACING), command = self.onPiecePressed, location = [
                 xpos,
                 ypos], clickSound = None, pressEffect = 0, geom = tempGeom, relief = None)
             col.append(piece)
         
         self.grid.append(col)
     
     self.createGoalPieces()

# 需要导入模块: from RepairMincroGame import RepairMincroGame [as 别名]
# 或者: from RepairMincroGame.RepairMincroGame import _initVisuals [as 别名]
 def _initVisuals(self):
     RepairMincroGame._initVisuals(self)
     self.model = loader.loadModel('models/gui/pir_m_gui_srp_hammering_main')
     self.board = self.model.find('**/wood')
     self.board.reparentTo(self)
     self.board.setPos(-0.02, -2.0, 0.080000000000000002)
     self.board.setScale(1.3)
     self.board.setDepthTest(True)
     self.board.setDepthWrite(True)
     self.hammerSwinging = False
     self.nailParent = self.attachNewNode('nailParent')
     self.nails = []
     for i in range(self.config.nailCountRange[1]):
         nailModel = self.model.find('**/nail').copyTo(NodePath())
         nail = RepairNail(name = 'nail%i' % i, parent = self.nailParent, nailModel = nailModel)
         self.nails.append(nail)
     
     self.circle = aspect2d.attachNewNode('circle')
     self.circle.setHpr(0.0, 0.0, 0.0)
     self.circle.setZ(0.20000000000000001)
     self.reticleCursorPerfect = self.model.find('**/reticleCursorPerfect')
     self.reticleCursorPerfect.reparentTo(self.circle)
     self.reticleCursor = self.model.find('**/reticleCursor')
     self.reticleCursor.reparentTo(self.circle)
     self.hammer = self.model.find('**/hammerCursor')
     self.hammer.reparentTo(aspect2d)
     self.circle.stash()
     self.hammer.stash()

# 需要导入模块: from RepairMincroGame import RepairMincroGame [as 别名]
# 或者: from RepairMincroGame.RepairMincroGame import _initVisuals [as 别名]
 def _initVisuals(self):
     RepairMincroGame._initVisuals(self)
     self.model = loader.loadModel('models/gui/pir_m_gui_srp_pumping_main')
     self.visual = self.attachNewNode('visual')
     self.visual.setPos(-0.25, 0.0, 0.074999999999999997)
     goalTopLoc = self.model.find('**/locator_top')
     goalTopLoc.reparentTo(self.visual)
     goalBottomLoc = self.model.find('**/locator_bottom')
     goalBottomLoc.reparentTo(self.visual)
     self.goalPositions = (goalBottomLoc.getPos(self), goalTopLoc.getPos(self))
     self.greatLabel = DirectLabel(text = PLocalizer.Minigame_Repair_Pumping_Great, text_fg = (0.20000000000000001, 0.80000000000000004, 0.29999999999999999, 1.0), text_pos = (0.0, 0.59999999999999998), text_align = TextNode.ACenter, text_font = PiratesGlobals.getPirateFont(), relief = None, text_shadow = (0.0, 0.0, 0.0, 1.0), scale = (0.080000000000000002, 0.080000000000000002, 0.080000000000000002), pos = (-0.46500000000000002, 0.0, 0.0), parent = self)
     self.failLabel = DirectLabel(text = PLocalizer.Minigame_Repair_Pumping_Fail, text_fg = (0.80000000000000004, 0.20000000000000001, 0.29999999999999999, 1.0), text_pos = (0.0, 0.59999999999999998), text_align = TextNode.ARight, text_font = PiratesGlobals.getPirateFont(), text_shadow = (0.0, 0.0, 0.0, 1.0), relief = None, scale = (0.080000000000000002, 0.080000000000000002, 0.080000000000000002), pos = (-0.625, 0.0, 0.0), parent = self)
     self.shipBackground = self.model.find('**/static_ship_background')
     self.shipBackground.reparentTo(self.visual)
     self.waterMeter = self.model.find('**/sprite_waterBottom')
     self.waterMeter.reparentTo(self.visual)
     self.waterTop = self.model.find('**/sprite_waterTop')
     self.waterTop.reparentTo(self.visual)
     self.waterMeterTopLoc = self.waterMeter.find('**/locator_topOfShipWater')
     self.pumpBackground = self.model.find('**/pumpBackground')
     self.pumpBackground.reparentTo(self.visual)
     self.pumpWaterTop = self.model.find('**/sprite_pumpWaterTop')
     self.pumpWaterTop.reparentTo(self.visual)
     self.pumpWaterBottom = self.model.find('**/sprite_pumpWaterBottom')
     self.pumpWaterBottom.reparentTo(self.visual)
     self.pumpWaterTopLoc = self.pumpWaterBottom.find('**/locator_topOfPumpWater')
     self.pumpHandle = self.model.find('**/sprite_handle')
     self.pumpHandle.reparentTo(self.visual)
     self.pumpBar = self.model.find('**/static_pump')
     self.pumpBar.reparentTo(self.visual)
     self.goalBox = self.model.find('**/sprite_clickField')
     self.goalBox.reparentTo(self.visual)
     self.goalBox.setTransparency(1)
     self.enableGoalBox()
     self.pumpLine = self.model.find('**/sprite_bar')
     self.pumpLine.reparentTo(self.visual)
     self.ghostLine = self.visual.attachNewNode('ghostLine')
     self.pumpLine.getChild(0).copyTo(self.ghostLine)
     self.ghostLine.setScale(self.pumpLine.getScale())
     self.ghostLine.setColor(1.0, 0.20000000000000001, 0.20000000000000001, 1.0)
     self.shipForground = self.model.find('**/static_ship_foreground')
     self.shipForground.reparentTo(self.visual)
     cm = CardMaker('cardMaker')
     cm.setFrame(-0.33000000000000002, 0.33000000000000002, 0.0, 1.0)
     self.goalBox.setZ(self.goalPositions[TOP].getZ())
     self.goalBoxStartScale = self.goalBox.getSz()
     self.enableGoalBox()
     self.pumpWaterUpLerp = LerpFunc(self.setPumpWater, fromData = -0.10000000000000001, toData = 1.0, duration = 0.5)
     self.pumpWaterDownLerp = LerpFunc(self.setPumpWater, fromData = 1.0, toData = -0.10000000000000001, duration = 0.5)
     self.model.removeNode()
     del self.model

# 需要导入模块: from RepairMincroGame import RepairMincroGame [as 别名]
# 或者: from RepairMincroGame.RepairMincroGame import _initVisuals [as 别名]
 def _initVisuals(self):
     RepairMincroGame._initVisuals(self)
     self.setBin('fixed', 36)
     self.model = loader.loadModel('models/gui/pir_m_gui_srp_sawing_main')
     sawModel = self.model.find('**/saw')
     sawModel.setR(193)
     sawModel.setPos(0.90000000000000002, 0.0, -0.16500000000000001)
     sawModel.setBin('gui-popup', 0)
     self.sawButton = RepairSaw(parent = self, clickDownCommand = self.sawAttachedToMouse, clickUpCommand = self.sawRemovedFromMouse, geom = sawModel, text_pos = (0.20000000000000001, -0.29999999999999999), text_fg = (1, 0, 0, 1), scale = (0.29999999999999999, 0.29999999999999999, 0.29999999999999999), relief = None, pressEffect = 0, frameSize = (-0.050000000000000003, 1.05, -0.29999999999999999, 0.050000000000000003), rolloverSound = None, clickSound = None)
     self.sawingLine = RepairSawingLine(self, self.config.sawlineLineThickness, self.config.sawlineColor, self.config.sawlineLinespawnDist)
     self.progressDescriptionLabel = DirectLabel(text = PLocalizer.Minigame_Repair_Sawing_Description, text_fg = (1.0, 1.0, 1.0, 1.0), text_pos = (0.0, 0.0), text_shadow = (0.0, 0.0, 0.0, 1.0), text_font = PiratesGlobals.getPirateFont(), text_align = TextNode.ARight, relief = None, scale = (0.080000000000000002, 0.080000000000000002, 0.080000000000000002), pos = (-0.20000000000000001, 0.0, 0.5), parent = self)
     self.progressLabel = DirectLabel(text = PLocalizer.Minigame_Repair_Sawing_Thresholds[3], text_fg = (1.0, 1.0, 1.0, 1.0), text_pos = (0.0, 0.0), text_shadow = (0.0, 0.0, 0.0, 1.0), text_font = PiratesGlobals.getPirateFont(), text_align = TextNode.ALeft, relief = None, scale = (0.080000000000000002, 0.080000000000000002, 0.080000000000000002), pos = (-0.17999999999999999, 0.0, 0.5), parent = self)
     self.boardDestroyedLabel = DirectLabel(text = PLocalizer.Minigame_Repair_Sawing_Board_Destroyed, text_fg = (1.0, 0.0, 0.0, 1.0), text_pos = (0.0, 0.0), text_font = PiratesGlobals.getPirateFont(), text_shadow = (0.0, 0.0, 0.0, 1.0), relief = None, scale = (0.10000000000000001, 0.10000000000000001, 0.10000000000000001), pos = (0.0, 0.0, 0.10000000000000001), parent = self)
     self.boardDestroyedLabel.setBin('fixed', 38)
     self.boardDestroyedLabel.stash()

# 需要导入模块: from RepairMincroGame import RepairMincroGame [as 别名]
# 或者: from RepairMincroGame.RepairMincroGame import _initVisuals [as 别名]
 def _initVisuals(self):
     RepairMincroGame._initVisuals(self)
     self.model = loader.loadModel('models/gui/pir_m_gui_srp_careening_main')
     self.board = self.model.find('**/hull')
     self.board.reparentTo(self)
     self.board.setScale(1.0)
     self.board.setPos(-0.12, 0.0, 0.19)
     self.brush = self.model.find('**/brushCursor')
     self.brush.reparentTo(aspect2d)
     self.brush.stash()
     barnacleGeom = [
         self.model.find('**/barnacles/barnacle0'),
         self.model.find('**/barnacles/barnacle1'),
         self.model.find('**/barnacles/barnacle2')]
     self.barnacles = []
     for i in range(self.config.barnacleCountRange[1]):
         bGeom = barnacleGeom[random.randint(0, 1)].copyTo(NodePath('barnacle%i' % i))
         bGeom.setBin('fixed', 36)
         if random.random() < self.config.mossPercentage:
             mGeom = barnacleGeom[2].copyTo(NodePath('moss'))
             mGeom.reparentTo(bGeom)
             mGeom.setPos(random.uniform(0, self.config.mossPosVariance), 0.0, random.uniform(0, self.config.mossPosVariance))
             mGeom.setBin('fixed', 35)
         
         b = RepairBarnacle('barnacle%i' % i, bGeom)
         b.reparentTo(self)
         self.barnacles.append(b)
         b.stash()
     
     self.scrubPowerMeter = self.model.find('**/scrubMeter')
     self.scrubMeterBackground = self.model.find('**/scrubMeterBackground')
     self.scrubMeterBackground.setBin('fixed', 32)
     self.scrubMeterBar = self.model.find('**/scrubMeterBar')
     self.scrubMeterBar.setBin('fixed', 33)
     self.scrubMeterFrame = self.model.find('**/scrubMeterFrame')
     self.scrubMeterFrame.setBin('fixed', 34)
     self.scrubPowerMeter.reparentTo(self)
     self.scrubPowerMeter.setPos(0.68000000000000005, 0.0, 0.20000000000000001)
     self.scrubPowerMeter.setSz(1.25)
     self.pushLabel = DirectLabel(text = PLocalizer.Minigame_Repair_Careening_Power, pos = (0.68000000000000005, 0.0, -0.27000000000000002), text_fg = (1.0, 1.0, 1.0, 1.0), text_shadow = (0.0, 0.0, 0.0, 1.0), text_font = PiratesGlobals.getPirateFont(), scale = (0.080000000000000002, 0.080000000000000002, 0.080000000000000002), parent = self, relief = None)

# 需要导入模块: from RepairMincroGame import RepairMincroGame [as 别名]
# 或者: from RepairMincroGame.RepairMincroGame import _initVisuals [as 别名]
 def _initVisuals(self):
     RepairMincroGame._initVisuals(self)
     self.model = loader.loadModel('models/gui/pir_m_gui_srp_pitching_main')
     self.board = self.model.find('**/piece_hull')
     self.board.reparentTo(self)
     self.board.setPos(0.0, 0.0, 0.19)
     self.crossHair = self.model.find('**/crosshair')
     self.crossHair.reparentTo(base.a2dBackground)
     self.crossHair.setBin('fixed', 45)
     self.crossHair.setScale(1.0)
     self.crossHair.setColorScale(0.0, 1.0, 0.0, 1.0)
     self.crossHair.stash()
     self.bucketIdle = self.model.find('**/pitchCursor/idle')
     self.bucketIdle.reparentTo(base.a2dBackground)
     self.bucketIdle.setBin('fixed', 45)
     self.bucketIdle.setScale(1.3500000000000001)
     self.bucketIdle.stash()
     self.bucket = self.bucketIdle.copyTo(NodePath())
     self.bucket.reparentTo(base.a2dBackground)
     self.bucket.setHpr(0, 0, 90)
     self.bucket.setBin('fixed', 45)
     self.bucket.setScale(1.3500000000000001)
     self.bucket.stash()
     self.missPatch = NodePath('dummy')
     self.missPatchAsset = self.model.find('**/miss')
     self.missPatchAsset.reparentTo(self.missPatch)
     self.missPatch.reparentTo(self)
     self.missPatch.setScale(1.1000000000000001)
     self.missPatch.stash()
     self.missSeq = None
     index = 1
     while True:
         locator = self.model.find('**/locator_%i' % index)
         if locator.isEmpty():
             break
         
         self.locators.append(locator)
         index += 1