oldschool-toontown/toontown/coghq/DistributedLaserField.py

from panda3d.core import *
from direct.interval.IntervalGlobal import *
from .StomperGlobals import *
from direct.distributed import ClockDelta
from direct.showbase.PythonUtil import lerp
import math
from otp.level import DistributedEntity
from direct.directnotify import DirectNotifyGlobal
from panda3d.core import NodePath
from otp.level import BasicEntities
from direct.task import Task
from toontown.toonbase import ToontownGlobals
from toontown.coghq import BattleBlocker
from toontown.toonbase import TTLocalizer
import random

class DistributedLaserField(BattleBlocker.BattleBlocker):
    notify = DirectNotifyGlobal.directNotify.newCategory('DistributedLaserField')
    laserFieldModels = ['phase_9/models/cogHQ/square_stomper']

    def __init__(self, cr):
        BattleBlocker.BattleBlocker.__init__(self, cr)
        node = hidden.attachNewNode('DistributedNodePathEntity')
        if not hasattr(self, 'radius'):
            self.radius = 5
        if not hasattr(self, 'blockerX'):
            self.blockerX = 0.0
        if not hasattr(self, 'blockerY'):
            self.blockerY = 0.0
        self.blockerZ = -10000
        self.gridWireGN = None
        self.gridBeamGN = None
        self.traceWireGN = None
        self.traceBeamGN = None
        self.gridSeed = 0
        self.gridScaleX = 2.0
        self.gridScaleY = 2.0
        self.zFloat = 0.05
        self.projector = Point3(0, 0, 25)
        self.tracePath = []
        self.gridData = [[0, 0]] * 2
        self.gridNumX = 2
        self.gridNumY = 2
        self.tracePath.append((0.51, 0.51, 1))
        self.tracePath.append((0.59, 0.51, 1))
        self.tracePath.append((0.55, 0.59, 1))
        self.tracePath.append((0.51, 0.51, 1))
        self.gridSymbols = []
        self.makeGridSymbols()
        self.isToonIn = 0
        self.toonX = -1
        self.toonY = -1
        self.isToonInRange = 0
        self.detectCount = 0
        self.cameraHold = None
        self.gridGame = 'some game'
        self.gridGameText = ' '
        self.activeLF = 1
        self.successSound = loader.loadSfx('phase_11/audio/sfx/LB_capacitor_discharge_3.ogg')
        self.successTrack = Parallel(SoundInterval(self.successSound, node=self, volume=0.8))
        self.failSound = loader.loadSfx('phase_11/audio/sfx/LB_sparks_1.ogg')
        self.failTrack = Parallel(SoundInterval(self.failSound, node=self, volume=0.8))
        return

    def generateInit(self):
        self.notify.debug('generateInit')
        BattleBlocker.BattleBlocker.generateInit(self)

    def generate(self):
        self.notify.debug('generate')
        BasicEntities.DistributedNodePathEntity.generate(self)

    def announceGenerate(self):
        self.notify.debug('announceGenerate')
        BattleBlocker.BattleBlocker.announceGenerate(self)
        self.gridWireNode = self.attachNewNode('grid Wire Node')
        self.gridWireGN = GeomNode('grid wire')
        self.gridWireNode.attachNewNode(self.gridWireGN)
        self.gridWireNode.setRenderModeWireframe()
        self.gridWireNode.setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd))
        self.gridWireNode.setTwoSided(True)
        self.gridWireNode.setBin('fixed', 1)
        self.gridWireNode.setDepthWrite(False)
        self.gridBeamNode = self.attachNewNode('grid Beam Node')
        self.gridBeamGN = GeomNode('grid beam')
        self.gridBeamNode.attachNewNode(self.gridBeamGN)
        self.gridBeamNode.setTransparency(TransparencyAttrib.MAlpha)
        self.gridBeamNode.setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd))
        self.gridBeamNode.setTwoSided(True)
        self.gridBeamNode.setBin('fixed', 1)
        self.gridBeamNode.setDepthWrite(False)
        self.traceWireNode = self.attachNewNode('trace Wire Node')
        self.traceWireGN = GeomNode('trace Wire')
        self.traceWireNode.attachNewNode(self.traceWireGN)
        self.traceWireNode.setRenderModeWireframe()
        self.traceWireNode.setTransparency(TransparencyAttrib.MAlpha)
        self.traceWireNode.setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd))
        self.traceWireNode.setTwoSided(True)
        self.traceWireNode.setBin('fixed', 1)
        self.traceWireNode.setDepthWrite(False)
        self.traceBeamNode = self.attachNewNode('trace Beam Node')
        self.traceBeamGN = GeomNode('trace Beam')
        self.traceBeamNode.attachNewNode(self.traceBeamGN)
        self.traceBeamNode.setTransparency(TransparencyAttrib.MAlpha)
        self.traceBeamNode.setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd))
        self.traceBeamNode.setTwoSided(True)
        self.traceBeamNode.setBin('fixed', 1)
        self.traceBeamNode.setDepthWrite(False)
        self.loadModel()
        self.detectName = 'laserField %s' % self.doId
        taskMgr.doMethodLater(0.1, self.__detect, self.detectName)

    def initCollisionGeom(self):
        pass

    def setGridGame(self, gameName):
        self.gridGame = gameName
        self.gridGameText = gameName
        if gameName == 'MineSweeper':
            self.gridGameText = TTLocalizer.LaserGameMine
        elif gameName == 'Roll':
            self.gridGameText = TTLocalizer.LaserGameRoll
        elif gameName == 'Avoid':
            self.gridGameText = TTLocalizer.LaserGameAvoid
        elif gameName == 'Drag':
            self.gridGameText = TTLocalizer.LaserGameDrag
        else:
            self.gridGameText = TTLocalizer.LaserGameDefault

    def setActiveLF(self, active = 1):
        if active:
            self.activeLF = 1
        else:
            self.activeLF = 0

    def setSuccess(self, success):
        if success:
            self.successTrack.start()
        else:
            self.startBattle()
            self.failTrack.start()
            self.cSphereNodePath.setPos(self.blockerX, self.blockerY, 0)

    def makeGridSymbols(self):
        symbolBlank = [0, (1.0, 0.0, 0.0), ()]
        symbolOne = [None, (1.0, 0.0, 0.0), ((0.45, 0.8),
          (0.55, 0.8),
          (0.55, 0.2),
          (0.45, 0.2),
          (0.45, 0.8))]
        symbolTwo = [None, (1.0, 0.0, 0.0), ((0.3, 0.8),
          (0.7, 0.8),
          (0.7, 0.45),
          (0.4, 0.45),
          (0.4, 0.3),
          (0.7, 0.3),
          (0.7, 0.2),
          (0.3, 0.2),
          (0.3, 0.55),
          (0.6, 0.55),
          (0.6, 0.7),
          (0.3, 0.7),
          (0.3, 0.8))]
        symbolThree = [None, (1.0, 0.0, 0.0), ((0.3, 0.8),
          (0.7, 0.8),
          (0.7, 0.2),
          (0.3, 0.2),
          (0.3, 0.3),
          (0.6, 0.3),
          (0.6, 0.45),
          (0.4, 0.45),
          (0.4, 0.55),
          (0.6, 0.55),
          (0.6, 0.7),
          (0.3, 0.7),
          (0.3, 0.8))]
        symbolFour = [None, (1.0, 0.0, 0.0), ((0.3, 0.8),
          (0.4, 0.8),
          (0.4, 0.6),
          (0.6, 0.6),
          (0.6, 0.8),
          (0.7, 0.8),
          (0.7, 0.2),
          (0.6, 0.2),
          (0.6, 0.5),
          (0.3, 0.5),
          (0.3, 0.8))]
        symbolFive = [None, (1.0, 0.0, 0.0), ((0.3, 0.8),
          (0.4, 0.8),
          (0.4, 0.6),
          (0.6, 0.6),
          (0.6, 0.8),
          (0.7, 0.8),
          (0.7, 0.2),
          (0.6, 0.2),
          (0.6, 0.5),
          (0.3, 0.5),
          (0.3, 0.8))]
        symbolSix = [None, (1.0, 0.0, 0.0), ((0.3, 0.8),
          (0.4, 0.8),
          (0.4, 0.6),
          (0.6, 0.6),
          (0.6, 0.8),
          (0.7, 0.8),
          (0.7, 0.2),
          (0.6, 0.2),
          (0.6, 0.5),
          (0.3, 0.5),
          (0.3, 0.8))]
        symbolSeven = [None, (1.0, 0.0, 0.0), ((0.3, 0.8),
          (0.4, 0.8),
          (0.4, 0.6),
          (0.6, 0.6),
          (0.6, 0.8),
          (0.7, 0.8),
          (0.7, 0.2),
          (0.6, 0.2),
          (0.6, 0.5),
          (0.3, 0.5),
          (0.3, 0.8))]
        symbolEight = [None, (1.0, 0.0, 0.0), ((0.3, 0.8),
          (0.4, 0.8),
          (0.4, 0.6),
          (0.6, 0.6),
          (0.6, 0.8),
          (0.7, 0.8),
          (0.7, 0.2),
          (0.6, 0.2),
          (0.6, 0.5),
          (0.3, 0.5),
          (0.3, 0.8))]
        symbolNine = [None, (1.0, 0.0, 0.0), ((0.3, 0.8),
          (0.4, 0.8),
          (0.4, 0.6),
          (0.6, 0.6),
          (0.6, 0.8),
          (0.7, 0.8),
          (0.7, 0.2),
          (0.6, 0.2),
          (0.6, 0.5),
          (0.3, 0.5),
          (0.3, 0.8))]
        symbolSquare = [None, (1.0, 0.0, 0.0), ((0.1, 0.9),
          (0.9, 0.9),
          (0.9, 0.1),
          (0.1, 0.1),
          (0.1, 0.9))]
        symbolTriangle = [None, (0.0, 1.0, 0.0), ((0.1, 0.1),
          (0.5, 0.9),
          (0.9, 0.1),
          (0.1, 0.1))]
        symbolBlueSquare = [None, (0.3, 0.3, 1.0), ((0.1, 0.9),
          (0.9, 0.9),
          (0.9, 0.1),
          (0.1, 0.1),
          (0.1, 0.9))]
        symbolHiddenBomb = [self.sendFail, (1.0, 0.0, 0.0), ((0.1, 0.9),
          (0.9, 0.9),
          (0.9, 0.1),
          (0.1, 0.1),
          (0.1, 0.9))]
        symbolBomb = [self.sendFail, (1.0, 0.0, 0.0), ((0.8, 1.0),
          (1.0, 0.8),
          (0.8, 0.6),
          (0.8, 0.4),
          (0.6, 0.2),
          (0.4, 0.2),
          (0.2, 0.4),
          (0.2, 0.6),
          (0.4, 0.8),
          (0.6, 0.8),
          (0.8, 1.0))]
        symbolSkull = [self.sendFail, (1.0, 0.0, 0.0), ((0.5, 0.9),
          (0.7, 0.8),
          (0.7, 0.6),
          (0.6, 0.5),
          (0.6, 0.4),
          (0.5, 0.4),
          (0.5, 0.3),
          (0.7, 0.4),
          (0.8, 0.4),
          (0.8, 0.3),
          (0.7, 0.3),
          (0.6, 0.25),
          (0.7, 0.2),
          (0.8, 0.2),
          (0.8, 0.1),
          (0.7, 0.1),
          (0.5, 0.2),
          (0.3, 0.1),
          (0.2, 0.1),
          (0.2, 0.2),
          (0.3, 0.2),
          (0.4, 0.25),
          (0.3, 0.3),
          (0.2, 0.3),
          (0.2, 0.4),
          (0.3, 0.4),
          (0.5, 0.3),
          (0.5, 0.4),
          (0.4, 0.4),
          (0.4, 0.5),
          (0.3, 0.6),
          (0.3, 0.8),
          (0.5, 0.9))]
        symbolDot = [None, (1.0, 0.0, 0.0), ((0.4, 0.6),
          (0.6, 0.6),
          (0.6, 0.4),
          (0.4, 0.4),
          (0.4, 0.6))]
        symbolRedX = [None, (1.0, 0.0, 0.0), ((0.3, 0.8),
          (0.5, 0.6),
          (0.7, 0.8),
          (0.8, 0.7),
          (0.6, 0.5),
          (0.8, 0.3),
          (0.7, 0.2),
          (0.5, 0.4),
          (0.3, 0.2),
          (0.2, 0.3),
          (0.4, 0.5),
          (0.2, 0.7),
          (0.3, 0.8))]
        self.symbolSelect = [(1.0, 0.0, 0.0), ((0.05, 0.95),
          (0.95, 0.95),
          (0.95, 0.05),
          (0.05, 0.05),
          (0.05, 0.95))]
        symbolBlueDot = [None, (0.5, 0.5, 1.0), ((0.5, 0.7),
          (0.7, 0.5),
          (0.5, 0.3),
          (0.3, 0.5),
          (0.5, 0.7))]
        self.gridSymbols = []
        self.gridSymbols.append(symbolBlank)
        self.gridSymbols.append(symbolOne)
        self.gridSymbols.append(symbolTwo)
        self.gridSymbols.append(symbolThree)
        self.gridSymbols.append(symbolFour)
        self.gridSymbols.append(symbolFive)
        self.gridSymbols.append(symbolSix)
        self.gridSymbols.append(symbolSeven)
        self.gridSymbols.append(symbolEight)
        self.gridSymbols.append(symbolNine)
        self.gridSymbols.append(symbolSquare)
        self.gridSymbols.append(symbolHiddenBomb)
        self.gridSymbols.append(symbolSkull)
        self.gridSymbols.append(symbolTriangle)
        self.gridSymbols.append(symbolDot)
        self.gridSymbols.append(symbolBlueSquare)
        self.gridSymbols.append(symbolRedX)
        self.gridSymbols.append(symbolBlueDot)
        return None

    def sendFail(self):
        self.sendUpdate('trapFire', [])

    def __detect(self, task):
        distance = self.centerNode.getDistance(localAvatar)
        greaterDim = self.gridScaleX
        if self.gridScaleY > self.gridScaleX:
            greaterDim = self.gridScaleY
        self.detectCount += 1
        if self.detectCount > 5:
            self.detectCount = 0
        if distance < greaterDim * 0.75:
            if not self.isToonInRange:
                self.doToonInRange()
            if localAvatar.getPos(self)[0] > 0 and localAvatar.getPos(self)[0] < self.gridScaleX and localAvatar.getPos(self)[1] > 0 and localAvatar.getPos(self)[1] < self.gridScaleY:
                self.__toonHit()
            else:
                if self.isToonIn:
                    self.toonX = -1
                    self.toonY = -1
                    self.isToonIn = 0
                    self.genGrid()
                self.isToonIn = 0
        elif self.isToonInRange:
            self.doToonOutOfRange()
        taskMgr.doMethodLater(0.1, self.__detect, self.detectName)
        return Task.done

    def doToonInRange(self):
        self.isToonInRange = 1
        if self.activeLF:
            camHeight = base.localAvatar.getClampedAvatarHeight()
            heightScaleFactor = camHeight * 0.3333333333
            defLookAt = Point3(0.0, 1.5, camHeight)
            cameraPoint = Point3(0.0, -20.0 * heightScaleFactor, camHeight + 8.0)
            base.localAvatar.setIdealCameraPos(cameraPoint)
            self.level.stage.showInfoText(self.gridGameText)

    def doToonOutOfRange(self):
        self.isToonInRange = 0
        base.localAvatar.setCameraPositionByIndex(base.localAvatar.cameraIndex)
        self.cameraHold = None
        return

    def __toonHit(self):
        posX = localAvatar.getPos(self)[0]
        posY = localAvatar.getPos(self)[1]
        tileX = int(posX / (self.gridScaleX / self.gridNumX))
        tileY = int(posY / (self.gridScaleY / self.gridNumY))
        oldX = self.toonX
        oldY = self.toonY
        if self.toonX != tileX or self.toonY != tileY or not self.isToonIn:
            self.toonX = tileX
            self.toonY = tileY
            self.isToonIn = 1
            if self.gridData[tileX][tileY] < len(self.gridSymbols):
                tileFunction = self.gridSymbols[self.gridData[tileX][tileY]][0]
                if tileFunction:
                    tileFunction()
            self.sendHit(self.toonX, self.toonY, oldX, oldY)
            self.genGrid()
        self.isToonIn = 1

    def __testTile(self):
        if self.toonX >= 0 and self.toonY >= 0 and self.toonX < self.gridNumX and self.toonY < self.gridNumY:
            if self.gridData[self.toonX][self.toonY] < len(self.gridSymbols):
                tileFunction = self.gridSymbols[self.gridData[self.toonX][self.toonY]][0]
                if tileFunction:
                    tileFunction()

    def sendHit(self, newX, newY, oldX, oldY):
        if self.toonX >= 0:
            self.sendUpdate('hit', [newX,
             newY,
             oldX,
             oldY])

    def disable(self):
        self.notify.debug('disable')
        if self.failTrack.isPlaying():
            self.failTrack.finish()
        if self.successTrack.isPlaying():
            self.successTrack.finish()
        self.ignoreAll()
        taskMgr.remove(self.detectName)
        BattleBlocker.BattleBlocker.disable(self)

    def delete(self):
        self.notify.debug('delete')
        self.unloadModel()
        BattleBlocker.BattleBlocker.delete(self)

    def loadModel(self):
        self.rotateNode = self.attachNewNode('rotate')
        self.model = None
        self.centerNode = self.attachNewNode('center')
        self.centerNode.setPos(self.gridScaleX * 0.5, self.gridScaleY * 0.5, 0.0)
        self.genGrid()
        return

    def unloadModel(self):
        if self.model:
            self.model.removeNode()
            del self.model
            self.model = None
        return

    def genTrace(self):
        wireRed = 1.0
        wireGreen = 0.0
        wireBlue = 0.0
        wireAlpha = 0.5
        beamRed = 0.04
        beamGreen = 0.0
        beamBlue = 0.0
        beamAlpha = 0.1
        self.gFormat = GeomVertexFormat.getV3cp()
        self.traceWireVertexData = GeomVertexData('holds my vertices', self.gFormat, Geom.UHDynamic)
        self.traceWireVertexWriter = GeomVertexWriter(self.traceWireVertexData, 'vertex')
        self.traceWireColorWriter = GeomVertexWriter(self.traceWireVertexData, 'color')
        self.traceBeamVertexData = GeomVertexData('holds my vertices', self.gFormat, Geom.UHDynamic)
        self.traceBeamVertexWriter = GeomVertexWriter(self.traceBeamVertexData, 'vertex')
        self.traceBeamColorWriter = GeomVertexWriter(self.traceBeamVertexData, 'color')
        self.traceWireVertexWriter.addData3f(self.projector[0], self.projector[1], self.projector[2])
        self.traceWireColorWriter.addData4f(wireRed, wireGreen, wireBlue, wireAlpha)
        self.traceBeamVertexWriter.addData3f(self.projector[0], self.projector[1], self.projector[2])
        self.traceBeamColorWriter.addData4f(0.0, 0.0, 0.0, 0.0)
        for vertex in self.tracePath:
            self.traceWireVertexWriter.addData3f(vertex[0] * self.gridScaleX, vertex[1] * self.gridScaleY, self.zFloat)
            self.traceWireColorWriter.addData4f(wireRed, wireGreen, wireBlue, wireAlpha)
            self.traceBeamVertexWriter.addData3f(vertex[0] * self.gridScaleX, vertex[1] * self.gridScaleY, self.zFloat)
            self.traceBeamColorWriter.addData4f(beamRed, beamGreen, beamBlue, beamAlpha)

        self.traceBeamTris = GeomTriangles(Geom.UHStatic)
        self.traceWireTris = GeomLinestrips(Geom.UHStatic)
        vertexCounter = 1
        sizeTrace = len(self.tracePath)
        chainTrace = sizeTrace - 1
        previousTrace = 1
        for countVertex in range(0, sizeTrace):
            self.traceWireTris.addVertex(countVertex + 1)

        self.traceWireTris.closePrimitive()
        for countVertex in range(0, chainTrace):
            self.traceBeamTris.addVertex(0)
            self.traceBeamTris.addVertex(countVertex + 1)
            self.traceBeamTris.addVertex(countVertex + 2)
            self.traceBeamTris.closePrimitive()

        self.traceWireGeom = Geom(self.traceWireVertexData)
        self.traceWireGeom.addPrimitive(self.traceWireTris)
        self.traceWireGN.addGeom(self.traceWireGeom)
        self.traceBeamGeom = Geom(self.traceBeamVertexData)
        self.traceBeamGeom.addPrimitive(self.traceBeamTris)
        self.traceBeamGN.addGeom(self.traceBeamGeom)

    def createGrid(self):
        gridScaleX = self.gridScaleX / self.gridNumX
        gridScaleY = self.gridScaleY / self.gridNumY
        red = 0.25
        green = 0.25
        blue = 0.25
        alpha = 0.5
        beamRed = 0.04
        beamGreen = 0.04
        beamBlue = 0.04
        beamAlpha = 0.1
        self.gFormat = GeomVertexFormat.getV3cp()
        self.gridVertexData = GeomVertexData('holds my vertices', self.gFormat, Geom.UHDynamic)
        self.gridVertexWriter = GeomVertexWriter(self.gridVertexData, 'vertex')
        self.gridColorWriter = GeomVertexWriter(self.gridVertexData, 'color')
        self.beamVertexData = GeomVertexData('holds my vertices', self.gFormat, Geom.UHDynamic)
        self.beamVertexWriter = GeomVertexWriter(self.beamVertexData, 'vertex')
        self.beamColorWriter = GeomVertexWriter(self.beamVertexData, 'color')
        self.gridVertexWriter.addData3f(self.projector[0], self.projector[1], self.projector[2])
        self.gridColorWriter.addData4f(red, green, blue, 0.0)
        self.beamVertexWriter.addData3f(self.projector[0], self.projector[1], self.projector[2])
        self.beamColorWriter.addData4f(0.0, 0.0, 0.0, 0.0)
        border = 0.4
        for column in range(0, self.gridNumX):
            columnLeft = 0.0 + gridScaleX * column
            columnRight = columnLeft + gridScaleX
            rowBottom = 0
            for row in range(0, self.gridNumY):
                rowTop = rowBottom + gridScaleY
                if self.gridData[column][row] and self.gridData[column][row] < len(self.gridSymbols):
                    gridColor = self.gridSymbols[self.gridData[column][row]][1]
                    gridSymbol = self.gridSymbols[self.gridData[column][row]][2]
                    sizeSymbol = len(gridSymbol)
                    for iVertex in range(sizeSymbol):
                        vertex = gridSymbol[iVertex]
                        self.gridVertexWriter.addData3f(columnLeft + vertex[0] * gridScaleX, rowBottom + vertex[1] * gridScaleY, self.zFloat)
                        self.gridColorWriter.addData4f(gridColor[0] * red, gridColor[1] * green, gridColor[2] * blue, alpha)
                        self.beamVertexWriter.addData3f(columnLeft + vertex[0] * gridScaleX, rowBottom + vertex[1] * gridScaleY, self.zFloat)
                        self.beamColorWriter.addData4f(gridColor[0] * beamRed, gridColor[1] * beamGreen, gridColor[2] * beamBlue, beamAlpha)

                rowBottom = rowTop

        if self.isToonIn:
            gridSymbol = self.symbolSelect[1]
            gridColor = self.symbolSelect[0]
            sizeSymbol = len(gridSymbol)
            for iVertex in range(sizeSymbol):
                vertex = gridSymbol[iVertex]
                self.gridVertexWriter.addData3f(self.toonX * gridScaleX + vertex[0] * gridScaleX, self.toonY * gridScaleY + vertex[1] * gridScaleY, self.zFloat)
                self.gridColorWriter.addData4f(gridColor[0] * red, gridColor[1] * green, gridColor[2] * blue, alpha)
                self.beamVertexWriter.addData3f(self.toonX * gridScaleX + vertex[0] * gridScaleX, self.toonY * gridScaleY + vertex[1] * gridScaleY, self.zFloat)
                self.beamColorWriter.addData4f(gridColor[0] * beamRed, gridColor[1] * beamGreen, gridColor[2] * beamBlue, beamAlpha)

        self.gridTris = GeomLinestrips(Geom.UHDynamic)
        self.beamTris = GeomTriangles(Geom.UHDynamic)
        vertexCounter = 1
        for column in range(0, self.gridNumX):
            for row in range(0, self.gridNumY):
                if self.gridData[column][row] and self.gridData[column][row] < len(self.gridSymbols):
                    gridSymbol = self.gridSymbols[self.gridData[column][row]][2]
                    sizeSymbol = len(gridSymbol)
                    for iVertex in range(sizeSymbol):
                        self.gridTris.addVertex(vertexCounter + iVertex)

                    self.gridTris.closePrimitive()
                    for iVertex in range(sizeSymbol - 1):
                        self.beamTris.addVertex(0)
                        self.beamTris.addVertex(vertexCounter + iVertex + 0)
                        self.beamTris.addVertex(vertexCounter + iVertex + 1)
                        self.beamTris.closePrimitive()

                    vertexCounter += sizeSymbol

        if self.isToonIn:
            gridSymbol = self.symbolSelect[1]
            sizeSymbol = len(gridSymbol)
            for iVertex in range(sizeSymbol):
                self.gridTris.addVertex(vertexCounter + iVertex)

            self.gridTris.closePrimitive()
            for iVertex in range(sizeSymbol - 1):
                self.beamTris.addVertex(0)
                self.beamTris.addVertex(vertexCounter + iVertex + 0)
                self.beamTris.addVertex(vertexCounter + iVertex + 1)
                self.beamTris.closePrimitive()

        self.wireGeom = Geom(self.gridVertexData)
        self.wireGeom.addPrimitive(self.gridTris)
        self.gridWireGN.addGeom(self.wireGeom)
        self.beamGeom = Geom(self.beamVertexData)
        self.beamGeom.addPrimitive(self.beamTris)
        self.gridBeamGN.addGeom(self.beamGeom)

    def setGrid(self, gridNumX, gridNumY):
        self.gridNumX = gridNumX
        self.gridNumY = gridNumY
        self.gridData = []
        for i in range(0, gridNumX):
            self.gridData.append([0] * gridNumY)

        self.genGrid()

    def getGrid(self):
        return (self.gridNumX, self.gridNumY)

    def setGridScaleX(self, gridScale):
        self.gridScaleX = gridScale
        self.centerNode.setPos(self.gridScaleX * 0.5, self.gridScaleY * 0.5, 0.0)
        self.blockerX = self.gridScaleX * 0.5
        self.cSphereNodePath.setPos(self.blockerX, self.blockerY, self.blockerZ)
        self.genGrid()

    def setGridScaleY(self, gridScale):
        self.gridScaleY = gridScale
        self.centerNode.setPos(self.gridScaleX * 0.5, self.gridScaleY * 0.5, 0.0)
        self.blockerY = self.gridScaleY
        self.cSphereNodePath.setPos(self.blockerX, self.blockerY, self.blockerZ)
        self.genGrid()

    def setField(self, fieldData):
        if fieldData[0] != self.gridNumX or fieldData[1] != self.gridNumY:
            self.setGrid(fieldData[0], fieldData[1])
        fieldCounter = 2
        for column in range(0, self.gridNumX):
            for row in range(0, self.gridNumY):
                if len(fieldData) > fieldCounter:
                    self.gridData[column][row] = fieldData[fieldCounter]
                    fieldCounter += 1

        self.genGrid()
        self.__testTile()

    def getField(self):
        fieldData.append(self.game.gridNumX)
        fieldData.append(self.game.gridNumY)
        fieldData = []
        for column in range(0, self.game.gridNumX):
            for row in range(0, self.game.gridNumY):
                fieldData.append(self.game.gridData[column][row])

        return fieldData

    def setSeed(self, seed):
        self.gridSeed = seed
        random.seed(seed)
        for column in range(0, self.gridNumX):
            for row in range(0, self.gridNumY):
                rint = random.randint(0, 2)
                self.gridData[column][row] = rint

        self.genGrid()

    def getSeed(self):
        return self.gridSeed

    def setMode(self, mode):
        self.mode = mode

    def getMode(self):
        return self.mode

    def setProjector(self, projPoint):
        self.projector = projPoint
        if self.gridWireGN and self.gridBeamGN:
            self.genGrid()

    def genGrid(self):
        if self.activeLF:
            if self.gridWireGN:
                self.gridWireGN.removeAllGeoms()
            if self.gridBeamGN:
                self.gridBeamGN.removeAllGeoms()
            if self.gridWireGN and self.gridBeamGN:
                self.createGrid()

    def hideSuit(self, suitIdarray):
        for suitId in suitIdarray:
            suit = base.cr.doId2do.get(suitId)
            if suit:
                suit.stash()

    def showSuit(self, suitIdarray):
        for suitId in suitIdarray:
            suit = base.cr.doId2do.get(suitId)
            if suit:
                suit.unstash()
                suit.setVirtual()

    def initCollisionGeom(self):
        print('Laser Field initCollisionGeom')
        self.blockerX = self.gridScaleX * 0.5
        self.blockerY = self.gridScaleY
        self.cSphere = CollisionSphere(0, 0, 0, self.blockerX)
        self.cSphereNode = CollisionNode('battleBlocker-%s-%s' % (self.level.getLevelId(), self.entId))
        self.cSphereNode.addSolid(self.cSphere)
        self.cSphereNodePath = self.attachNewNode(self.cSphereNode)
        self.cSphereNodePath.setPos(self.blockerX, self.blockerY, self.blockerZ)
        self.cSphereNode.setCollideMask(ToontownGlobals.WallBitmask)
        self.cSphere.setTangible(0)
        self.enterEvent = 'enter' + self.cSphereNode.getName()
        self.accept(self.enterEvent, self.__handleToonEnter)

    def __handleToonEnter(self, collEntry):
        self.notify.debug('__handleToonEnter, %s' % self.entId)
        self.sendFail()