Collision wont stop my cube--few other problems and question

Scripting Issues
1

Hi I have a few questions and problems going on in my code. Code will be posted below.

  1. Problem, When I move my camera using the same code with my cube and push down as I look at the floor the cube seems to just go right tho it while if I do the same with my camera it doesnt, if I switch the code around that is.

–> working 2. Adding to problem 1 with question, Also I think I need to change self.usertoon.setPos(self.usertoon.getPos() - camleftright*(elapsed*25)) with self.usertoon.setPos(self.usertoon.getPos() - userleftright(elapsed25)) but it seems to make my cube to not work when I do, why is this so?

  1. Question, Maybe my collision not setup right, but I want to “push” the cube when my camera collision is set up too, how would I go about this?

  2. Question, Last, how would I go about setting up a array or list to setup a new loadModelCopy for when say someone else log on into my game? I have test code but it doesnt seem to work and cause my game to “pause” when used. -so it may be a little mess up-

#(1,2,3) 1:leftright,2:forwardbackwords,3:updown

import direct.directbase.DirectStart  #Initialize Panda and create a window
import random, sys, os, math, time, threading, socket          #libs
from direct.gui.OnscreenText import OnscreenText
from direct.task.Task import Task     #Task run
from pandac.PandaModules import Fog
from pandac.PandaModules import * 
from pandac.PandaModules import Shader
from pandac.PandaModules import Point3,Vec4
from pandac.PandaModules import NodePath
from pandac.PandaModules import CollisionTraverser,CollisionNode
from pandac.PandaModules import CollisionHandlerQueue,CollisionRay
from direct.showbase.DirectObject import DirectObject
#-----------------------------------------------------


class World(DirectObject):
    def __init__(self):
      self.zone = "town"
      self.loadzone()
      self.camera()
      self.Collisions()
      self.Controls()
      self.connect()


######################### Key movement ########################################
    def Controls(self): 
      self.keyMap = {"left":0, "right":0, "forward":0, "back":0, "fps":0, "fullscreen":0}
      # Accept the control keys for movement
      self.accept("escape", sys.exit) 
      self.accept("arrow_left", self.setKey, ["left",1]) 
      self.accept("arrow_right", self.setKey, ["right",1])
      self.accept("arrow_up", self.setKey, ["forward",1])
      self.accept("arrow_down", self.setKey, ["back",1])
      self.accept("`", self.setKey, ["fps",1])
      self.accept("+", self.setKey, ["fullscreen",1])
      self.accept("arrow_left-up", self.setKey, ["left",0]) 
      self.accept("arrow_right-up", self.setKey, ["right",0]) 
      self.accept("arrow_up-up", self.setKey, ["forward",0])
      self.accept("arrow_down-up", self.setKey, ["back",0])
      self.accept("`-up", self.setKey, ["fps",0])
      self.accept("+-up", self.setKey, ["fullscreen",0])
      
      
      taskMgr.add(self.move,"moveTask")
   #   taskMgr.add(self.askfor,"connectionTask")


###############################################################################     
      #Game state variables 
      self.prevtime = 0
      self.runforward = 0
      self.runback = 0
      self.FrameRateMeter = 0
      self.jump = 0
      self.full = 1
      self.userlist = []


###############################################################################
    def connect(self):
      self.client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
      self.client.connect (("76.215.140.97", 5000))
      self.Name = "Mradr"
      self.Password = "123"
      self.send="namepass"+" "+self.Name+" "+self.Password
      self.client.send(self.send)
      

###############################################################################
    #def askfor(self):
#      if self.client.recv(1024) == "":
 #       print "not nothing"
  #      return task.again
   #   self.read = self.client.recv(1024)
    #  self.data = self.read.split()
     # print self.data
      #if "connected" in self.read:
       # if not self.data[1] in self.userlist:
        #  self.userlist.append(self.data[1])
         # self.userlist.index(self.data[1]) = loader.loadModelCopy("towns/cube")
 #         self.userlist.index(self.data[1]).reparentTo(render)
  #    elif "isoffline" in self.read:
   #     self.userlist.remove(self.data[1])
    #  else:
     #   print self.read
     # return task.again

   
       
###############################################################################
    def loadzone(self):
      #Load the first environment model town.egg
      self.environ = loader.loadModel("towns/a1")
      self.usertoon = loader.loadModelCopy("towns/cube")
      self.environ.reparentTo(render)
      self.usertoon.reparentTo(render)
      self.environ.setScale(0.015,0.015,0.015) 
      self.environ.setPos(0,0,0)
      self.usertoon.setScale(0.015,0.015,0.015) 
      self.usertoon.setPos(0,10,5)
      
      
###############################################################################      
    def camera(self):
      base.disableMouse()
      if self.zone == self.zone:
        base.camera.setPos(0,0,10)
        base.camLens.setFar(700)
        #self.myFog = Fog("Fog Name")
        #self.myFog.setColor(167,162,154)
        #self.myFog.setExpDensity(.0001)
        #render.setFog(self.myFog)
        base.setBackgroundColor(0,0,0) #167,162,154
      elif self.zone == "towns/controlroom":
        base.camera.setPos(0,0,115) 
        base.camLens.setFar(2000)
        self.infoText['text']='Control Room'
        base.setBackgroundColor(0,0,0)
      elif self.zone == "towns/dg1":
        base.camera.setPos(0,0,115) 
        base.camLens.setFar(5000)
        self.infoText['text']='Dg1'
        self.myFog = Fog("Fog Name")
        self.myFog.setColor(167,162,154)
        self.myFog.setExpDensity(.001)
        render.setFog(self.myFog)
        base.setBackgroundColor(167,162,154)


###############################################################################
    def Collisions(self):
      base.cTrav = CollisionTraverser()
      base.pusher = CollisionHandlerPusher()
      base.pusher.setHorizontal(False)
      
  
      #cnodePath = base.camera.attachNewNode(CollisionNode('camera'))
      #cnodePath.node().addSolid(CollisionSphere(0, 0, 0, 2))
      cnodePath2 = self.usertoon.attachNewNode(CollisionNode('cube'))
      cnodePath2.node().addSolid(CollisionSphere(0, 0, 0, 5))
      #base.pusher.addCollider(cnodePath,base.camera,base.drive.node())
      base.pusher.addCollider(cnodePath2,self.usertoon,base.drive.node())
      #base.cTrav.addCollider(cnodePath,base.pusher)
      base.cTrav.addCollider(cnodePath2,base.pusher)



###############################################################################
    #Records the state of the arrow keys 
    def setKey(self, key, value): 
      self.keyMap[key] = value 


    def move(self, task):
      elapsed = task.time - self.prevtime
      camleftright = base.camera.getNetTransform().getMat().getRow3(0)
      camforwardback = base.camera.getNetTransform().getMat().getRow3(1)
      userleftright = self.usertoon.getNetTransform().getMat().getRow3(0) #test code
      userforwardback = self.usertoon.getNetTransform().getMat().getRow3(1) #test code
      if (self.keyMap["left"]!=0): 
          base.camera.setPos(base.camera.getPos() - camleftright*(elapsed*25))
          self.usertoon.setPos(self.usertoon.getPos() - camleftright*(elapsed*25))
      if (self.keyMap["right"]!=0): 
          base.camera.setPos(base.camera.getPos() + camleftright*(elapsed*25))
          self.usertoon.setPos(self.usertoon.getPos() + camleftright*(elapsed*25))
      if (self.keyMap["forward"]!=0):
          if self.runforward == 0:
            base.camera.setPos(base.camera.getPos() + camforwardback*(elapsed*25))
            self.usertoon.setPos(self.usertoon.getPos() + camforwardback*(elapsed*25))
            self.runforward = 1
          elif self.runforward == 1:
            base.camera.setPos(base.camera.getPos() + camforwardback*(elapsed*25))
            self.usertoon.setPos(self.usertoon.getPos() + camforwardback*(elapsed*25))
      if (self.keyMap["forward"]!=1):
          if self.runforward == 1:          
            self.runforward = 0
      if (self.keyMap["back"]!=0):
          if self.runback == 0:
            base.camera.setPos(base.camera.getPos() - camforwardback*(elapsed*25))
            self.usertoon.setPos(self.usertoon.getPos() - camforwardback*(elapsed*25))
            self.runback = 1
          elif self.runback == 1:
            base.camera.setPos(base.camera.getPos() - camforwardback*(elapsed*25))
            self.usertoon.setPos(self.usertoon.getPos() - camforwardback*(elapsed*25))
      if (self.keyMap["back"]!=1):
          if self.runback == 1:          
            self.runback = 0
      if (self.keyMap["fps"]!=0):
          time.sleep(.2)
          if self.FrameRateMeter == 0:
            base.setFrameRateMeter(1)
            self.FrameRateMeter = 1
          elif self.FrameRateMeter == 1:
            base.setFrameRateMeter(0)
            self.FrameRateMeter = 0
      if (self.keyMap["fullscreen"]!=0):
          time.sleep(.2)
          props = WindowProperties()
          if self.full == 0: 
            props.setFullscreen(False) 
            props.setUndecorated(False) 
            props.setOrigin(200,150) 
            props.setSize(800,600)
            self.full = 1 
          elif self.full == 1:
            props.setFullscreen(True)
            props.setOrigin(0,0) 
            props.setSize(1280,1024)
            self.full = 0
          base.win.requestProperties(props)
            

      if self.usertoon.getZ() > -100: 
        self.usertoon.setZ(self.usertoon.getZ()-.0505)
                             
      self.md = base.win.getPointer(0)
      self.x = self.md.getX()
      self.y = self.md.getY()
      if base.win.movePointer(0, base.win.getXSize()/2, base.win.getYSize()/2):
        base.camera.setP(base.camera.getP() -  (self.y - base.win.getYSize()/2)*0.4)
        base.camera.setH(base.camera.getH() - (self.x - base.win.getXSize()/2)*0.4)

      #store camrea pos
      startpos = base.camera.getPos()

      self.prevtime = task.time 
      return Task.cont
      
      
###############################################################################      
      
World()
run()

[/u]

2
  1. Your movement code is really weird. I don’t recommend using NetTransforms at all. (I know Roaming Ralph does it that way, but RR does a lot of things wrong.) Use something like this, rather:
      elapsed = task.time - self.prevtime
      if (self.keyMap["left"]!=0):
          base.camera.setX(base.camera, - (elapsed*25))
          self.usertoon.setX(self.usertoon, - (elapsed*25))
      if (self.keyMap["right"]!=0):
          base.camera.setX(base.camera, (elapsed*25))
          self.usertoon.setX(self.usertoon, (elapsed*25))
      if (self.keyMap["forward"]!=0):
          if self.runforward == 0:
            base.camera.setY(base.camera, (elapsed*25))
            self.usertoon.setY(self.usertoon, (elapsed*25))
            self.runforward = 1
          elif self.runforward == 1:
            base.camera.setY(base.camera, (elapsed*25))
            self.usertoon.setY(self.usertoon, (elapsed*25))

When you do this, though, make sure you’ve either didn’t scale your model after loading, or called flattenLight on it after scaling.

  1. loadModelCopy is deprecated. You shouldn’t use it - use loadModel instead.
3

Thanks for the help, Still have thos other problems sadly still, I think I fixs the cube going tho things tho with taking out the getnettransform movemnt code.