Collision for Player and Bot

I’m trying to implement a basic FPS game.I have the player moving through the map and also have a bot(Ralph) that runs around the map.
But the problem is I cannot bring about collisions for both the player and Ralph.
I can either implement it for player or Ralph.but not both.
Here’s a part of the code.Please help.

class Player(object):
        FORWARD = Vec3(0,2,0)
        BACK = Vec3(0,-1,0)
        LEFT = Vec3(-1,0,0)
        RIGHT = Vec3(1,0,0)
        STOP = Vec3(0)
        walk = STOP
        strafe = STOP
        speed = 50
        def __init__(self):
            self.loadModel()
            self.setUpCamera()
            self.attachControls()
            self.gun()
            self.initCollision()
            self.createCollisions()
            taskMgr.add(self.mouseUpdate, 'mouse-task')
            taskMgr.add(self.moveUpdate, 'move-task')
    
        def initCollision(self):
            """ create the collision system """
            base.cTrav = CollisionTraverser()
            base.pusher = CollisionHandlerPusher()
        def loadModel(self):
            """ make the nodepath for player """
            self.node = NodePath('player')
            self.node.reparentTo(render)
            self.node.setPos(0,0,2)
            self.node.setScale(.05)
        def setUpCamera(self):
            pl =  base.cam.node().getLens()
            pl.setFov(70)
            base.cam.node().setLens(pl)
            base.camera.reparentTo(self.node)        
        def mouseUpdate(self,task):
            md = base.win.getPointer(0)
            x = md.getX()
            y = md.getY()
            if base.win.movePointer(0, base.win.getXSize()/2, base.win.getYSize()/2):
                self.node.setH(self.node.getH() -  (x - base.win.getXSize()/2)*0.1)
                base.camera.setP(base.camera.getP() - (y - base.win.getYSize()/2)*0.1)
            return task.cont 
        def attachControls(self):
            base.accept( "s" , self.__setattr__,["walk",self.STOP] )
            base.accept( "w" , self.__setattr__,["walk",self.FORWARD])
            base.accept( "s" , self.__setattr__,["walk",self.BACK] )
            base.accept( "s-up" , self.__setattr__,["walk",self.STOP] )
            base.accept( "w-up" , self.__setattr__,["walk",self.STOP] )
            base.accept( "a" , self.__setattr__,["strafe",self.LEFT])
            base.accept( "d" , self.__setattr__,["strafe",self.RIGHT] )
            base.accept( "a-up" , self.__setattr__,["strafe",self.STOP] )
            base.accept( "d-up" , self.__setattr__,["strafe",self.STOP] )
        def moveUpdate(self,task): 
            self.node.setPos(self.node,self.walk*globalClock.getDt()*self.speed)
            self.node.setPos(self.node,self.strafe*globalClock.getDt()*self.speed)
            return task.cont
        def gun(self):
            self.gun = self.node.attachNewNode('gun')
            #self.gun = loader.loadModel('box')
            #self.gun.reparentTo(base.cam)
            #self.gun.setScale(0.20)
            #self.gun.setPos(0,1,0)
            self.ptr = self.node.attachNewNode('point')
            self.ptr = loader.loadModel('smiley')
            self.ptr.setScale(0.02)
            self.ptr.reparentTo(base.cam)
            self.ptr.setPos(0,2,0)
        def createCollisions(self):
            
            """ create a collision solid and ray for the player """
            cn = CollisionNode('player')
            cn.addSolid(CollisionSphere(0,0,0,3))
            solid = self.node.attachNewNode(cn)
            base.cTrav.addCollider(solid,base.pusher)
            base.pusher.addCollider(solid,self.node, base.drive.node())
            # init players floor collisions
            ray = CollisionRay()
            ray.setOrigin(0,0,-.2)
            ray.setDirection(0,0,-1)
            cn = CollisionNode('playerRay')
            cn.addSolid(ray)
            cn.setFromCollideMask(BitMask32.bit(0))
            cn.setIntoCollideMask(BitMask32.allOff())
            solid = self.node.attachNewNode(cn)
            self.nodeGroundHandler = CollisionHandlerQueue()
            base.cTrav.addCollider(solid, self.nodeGroundHandler)
            
class Ralph(object):
        
        def __init__(self):
            self.AIModels()
            self.setAI()
            self.initCollision()
            self.createCollisions()
        def initCollision(self):
            """ create the collision system """
            base.cTrav = CollisionTraverser()
            base.pusher = CollisionHandlerPusher()
        def AIModels(self):

            ralphStartPos = Vec3(-4, -2, -3)
            self.wanderer = Actor("models/ralph",
                                     {"run":"models/ralph-run"})
            self.wanderer.reparentTo(render)
            self.wanderer.setScale(0.25)
            self.wanderer.setPos(ralphStartPos)
            
        def setAI(self):
            #Creating AI World
            self.AIworld = AIWorld(render)
     
            self.AIchar = AICharacter("wanderer",self.wanderer, 100, 0.05, 5)
            self.AIworld.addAiChar(self.AIchar)
            self.AIbehaviors = self.AIchar.getAiBehaviors()
            
            self.AIbehaviors.wander(2, 0, 10, 1.0)
            self.wanderer.loop("run")
            
            #AI World update        
            taskMgr.add(self.AIUpdate,"AIUpdate")
            
        #to update the AIWorld    
        def AIUpdate(self,task):
            self.AIworld.update()            
            return Task.cont
        def createCollisions(self):
            """ create a collision solid and ray for the player """
            cn = CollisionNode('panda')
            cn.addSolid(CollisionSphere(0,0,0,3))
            solid = self.wanderer.attachNewNode(cn)
            base.cTrav.addCollider(solid,base.pusher)
            base.pusher.addCollider(solid,self.wanderer, base.drive.node())
            # init players floor collisions
            ray = CollisionRay()
            ray.setOrigin(0,0,-.2)
            ray.setDirection(0,0,-1)
            cn = CollisionNode('pandaRay')
            cn.addSolid(ray)
            cn.setFromCollideMask(BitMask32.bit(0))
            cn.setIntoCollideMask(BitMask32.allOff())
            solid = self.wanderer.attachNewNode(cn)
            self.nodeGroundHandler = CollisionHandlerQueue()
            base.cTrav.addCollider(solid, self.nodeGroundHandler)
            

FPS()
render.setShaderAuto()
run()

I think I have had this problem. The problem is that you have this code used twice:
Player:

""" create a collision solid and ray for the player """ 
            cn = CollisionNode('player') 
            cn.addSolid(CollisionSphere(0,0,0,3)) 
            solid = self.node.attachNewNode(cn) 
            base.cTrav.addCollider(solid,base.pusher) 
            base.pusher.addCollider(solid,self.node, base.drive.node()) 
            # init players floor collisions 
            ray = CollisionRay() 
            ray.setOrigin(0,0,-.2) 
            ray.setDirection(0,0,-1) 
            cn = CollisionNode('playerRay') 
            cn.addSolid(ray) 
            cn.setFromCollideMask(BitMask32.bit(0)) 
            cn.setIntoCollideMask(BitMask32.allOff()) 
            solid = self.node.attachNewNode(cn) 
            self.nodeGroundHandler = CollisionHandlerQueue() 
            base.cTrav.addCollider(solid, self.nodeGroundHandler) 

Bot:

            """ create a collision solid and ray for the player """ 
            cn = CollisionNode('panda') 
            cn.addSolid(CollisionSphere(0,0,0,3)) 
            solid = self.wanderer.attachNewNode(cn) 
            base.cTrav.addCollider(solid,base.pusher) 
            base.pusher.addCollider(solid,self.wanderer, base.drive.node()) 
            # init players floor collisions 
            ray = CollisionRay() 
            ray.setOrigin(0,0,-.2) 
            ray.setDirection(0,0,-1) 
            cn = CollisionNode('pandaRay') 
            cn.addSolid(ray) 
            cn.setFromCollideMask(BitMask32.bit(0)) 
            cn.setIntoCollideMask(BitMask32.allOff()) 
            solid = self.wanderer.attachNewNode(cn) 
            self.nodeGroundHandler = CollisionHandlerQueue() 
            base.cTrav.addCollider(solid, self.nodeGroundHandler) 

So this code…

            self.nodeGroundHandler = CollisionHandlerQueue() 
            base.cTrav.addCollider(solid, self.nodeGroundHandler)

…in the bots collision initiation overrides the players collision. Try just naming the players and bots variables to do with collision with different names. So “self.nodeGroundHandler” becomes “self.botNodeGroundHandler” for the bot. This should work, I think.