Pet file cleanup

toontown/pets/DistributedPetUD.py

@@ -3,53 +3,51 @@ from direct.distributed.DistributedObjectUD import DistributedObjectUD
 
 class DistributedPetUD(DistributedObjectUD):
     notify = DirectNotifyGlobal.directNotify.newCategory("DistributedPetUD")
-    
+
     def setDNA(self, dna):
         pass
 
     def setOwnerId(self, ownerId):
         pass
-        
+
     def setTraitSeed(self, traitSeed):
         pass
-        
+
     def setSafeZone(self, safeZone):
         pass
-        
+
     def setHead(self, head):
         pass
-        
+
     def setEars(self, ears):
         pass
-        
+
     def setNose(self, nose):
         pass
-        
+
     def setTail(self, tail):
         pass
-        
+
     def setBodyTexture(self, bodyTexture):
         pass
-        
+
     def setColor(self, color):
         pass
-        
+
     def setColorScale(self, colorScale):
         pass
-        
+
     def setEyeColor(self, eyeColor):
         pass
-        
+
     def setGender(self, gender):
         pass
-        
+
-    def setLastSeenTimestamp(self, timestamp):
-        pass
-    
-    def setTrickAptitudes(self, aptitudes):
-        pass
-        
     def setLastSeenTimestamp(self, timestamp):
         pass
 
-    
+    def setTrickAptitudes(self, aptitudes):
+        pass
+
+    def setLastSeenTimestamp(self, timestamp):
+        pass

toontown/pets/PetManagerAI.py

@@ -10,77 +10,73 @@ DAY = 24 * HOUR
 
 def getDayId():
     return int(time.time() // DAY)
-    
+
 class PetManagerAI:
-    NUM_DAILY_PETS = 5 # per hood
+    NUM_DAILY_PETS = 5 # Per hood.
     cachePath = config.GetString('air-pet-cache', 'astron/databases/air_cache/')
-    
+
     def __init__(self, air):
         self.air = air
         self.cacheFile = '%spets_%d.pets' % (self.cachePath, self.air.districtId)
         if os.path.isfile(self.cacheFile):
             with open(self.cacheFile, 'rb') as f:
                 data = f.read()
-                
+
             self.seeds = cPickle.loads(data)
             if self.seeds.get('day', -1) != getDayId() or len(self.seeds.get(ToontownGlobals.ToontownCentral, [])) != self.NUM_DAILY_PETS:
                 self.generateSeeds()
-            
         else:
-            self.generateSeeds()            
+            self.generateSeeds()
 
     def generateSeeds(self):
         seeds = range(0, 255)
         random.shuffle(seeds)
-        
+
         self.seeds = {}
         for hood in (ToontownGlobals.ToontownCentral, ToontownGlobals.DonaldsDock, ToontownGlobals.DaisyGardens,
                      ToontownGlobals.MinniesMelodyland, ToontownGlobals.TheBrrrgh, ToontownGlobals.DonaldsDreamland,
                      ToontownGlobals.FunnyFarm):
             self.seeds[hood] = [seeds.pop() for _ in xrange(self.NUM_DAILY_PETS)]
-            
+
         self.seeds['day'] = getDayId()
-            
+
         with open(self.cacheFile, 'wb') as f:
             f.write(cPickle.dumps(self.seeds))
 
     def getAvailablePets(self, seed, safezoneId):
         if self.seeds.get('day', -1) != getDayId():
             self.generateSeeds()
-            
+
         return list(set(self.seeds.get(safezoneId, [seed])))
 
     def createNewPetFromSeed(self, avId, seed, nameIndex, gender, safeZoneId):
         av = self.air.doId2do[avId]
-        
+
         name = TTLocalizer.getPetName(nameIndex)
         _, dna, traitSeed = PetUtil.getPetInfoFromSeed(seed, safeZoneId)
         head, ears, nose, tail, body, color, cs, eye, _ = dna
         numGenders = len(PetDNA.PetGenders)
         gender %= numGenders
-                
+
         fields = {'setOwnerId' : avId, 'setPetName' : name, 'setTraitSeed' : traitSeed, 'setSafeZone' : safeZoneId,
                   'setHead' : head, 'setEars' : ears, 'setNose' : nose, 'setTail' : tail, 'setBodyTexture' : body,
                   'setColor' : color, 'setColorScale' : cs, 'setEyeColor' : eye, 'setGender' : gender}
-                  
+
         def response(doId):
             if not doId:
                 self.air.notify.warning("Cannot create pet for %s!" % avId)
                 return
-                
+
             self.air.writeServerEvent('bought-pet', avId, doId)
             av.b_setPetId(doId)
-            
+
         self.air.dbInterface.createObject(self.air.dbId, self.air.dclassesByName['DistributedPetAI'],
                                           {k: (v,) for k,v in fields.items()}, response)
-        
+
     def deleteToonsPet(self, avId):
         av = self.air.doId2do[avId]
         pet = av.getPetId()
         if pet:
             if pet in self.air.doId2do:
                 self.air.doId2do[pet].requestDelete()
-                
         av.b_setPetId(0)
-        # XXX to do: check for current pet and destroy it if generated
-        

toontown/pets/PetMoverAI.py

@@ -15,14 +15,13 @@ def inCircle(x, y, c=estateCenter, r=estateRadius):
     center_x, center_y = c
     square_dist = (center_x - x) ** 2 + (center_y - y) ** 2
     return square_dist <= r ** 2
-    
+
 def housePointCollision(x, y):
     for i, h in enumerate(houses):
         if inCircle(x, y, h, houseRadius):
             return 1
-            
     return 0
-    
+
 def generatePos():
     def get():
         r = random.randint(0, estateRadius) - estateRadius / 2
@@ -31,39 +30,38 @@ def generatePos():
         y = r2 + estateCenter[1]
         assert inCircle(x, y)
         return x, y
-        
+
     p = get()
     while housePointCollision(*p):
         p = get()
-        
+
     return p
 
 def lineInCircle(pt1, pt2, circlePoint, circleRadius=houseRadius):
     x1, y1 = pt1
     x2, y2 = pt2
-    
+
     dist = math.hypot(x2 - x1, y2 - y1)
     if dist == 0:
         return 0
-  
+
     dx = (x2 - x1) / dist
     dy = (y2 - y1) / dist
-    
+
     t = dx * (circlePoint[0] - x1) + dy * (circlePoint[1] - y1)
-    
+
     ex = t * dx + x1
     ey = t * dy + y1
-    
+
     d2 = math.hypot(ex - circlePoint[0], ey - circlePoint[1])
     return d2 <= circleRadius
-                
+
 def houseCollision(pt1, pt2):
     for i, h in enumerate(houses):
         if lineInCircle(pt1, pt2, h):
             return 1
-            
     return 0
-    
+
 def generatePath(start, end):
     points = [start]
     if not houseCollision(start, end):
@@ -74,22 +72,22 @@ def generatePath(start, end):
         next = generatePos()
         while houseCollision(points[-1], next):
             next = generatePos()
-            
+
         points.append(next)
         if not houseCollision(next, end):
             points.append(end)
             return points
-            
+
 def angle(A, B):
     ax = A.getX()
     ay = A.getY()
-    
+
     bx = B.getX()
     by = B.getY()
-    
+
     return math.atan2(by-ay, bx-ax)
-    
+
-class PetMoverAI(FSM):    
+class PetMoverAI(FSM):
     def __init__(self, pet):
         self.pet = pet
         FSM.__init__(self, 'PetMoverAI-%d' % self.pet.doId)
@@ -99,91 +97,89 @@ class PetMoverAI(FSM):
         self.rotSpeed = 360.0
         self.__moveFromStill()
         self.__chaseCallback = None
-        
+
     def enterStill(self):
         taskMgr.doMethodLater(random.randint(15, 60), self.__moveFromStill, self.pet.uniqueName('next-state'))
-                
+
     def exitStill(self):
         taskMgr.remove(self.pet.uniqueName('next-state'))
-        
+
     def __moveFromStill(self, task=None):
-        choices = ["Wander"]            
+        choices = ["Wander"]
         nextState = random.choice(choices)
         self.request(nextState)
-        
+
     def enterWander(self):
         target = self.getPoint()
         self.walkToPoint(target)
-        
+
     def getPoint(self):
         x, y = generatePos()
         return Point3(x, y, 0)
-        
+
     def walkToPoint(self, target):
         here = self.pet.getPos()
         dist = Vec3(here - target).length()
-        
+
         self.__seq = Sequence(Func(self.pet.lookAt, target), Func(self.pet.setP, 0), self.pet.posInterval(dist / self.fwdSpeed, target, here),
                               Func(self.__stateComplete))
         self.__seq.start()
-        
+
     def exitWander(self):
         if self.__seq:
             self.__seq.pause()
-            
+
         self.__seq = None
-        
+
     def __stateComplete(self):
         try:
             self.request("Still")
-            
         except:
             pass
-        
+
     def destroy(self):
         self.demand("Off")
-        
+
     def setFwdSpeed(self, speed):
         self.fwdSpeed = speed
-        
+
     def getFwdSpeed(self):
         return self.fwdSpeed
-        
+
     def setRotSpeed(self, speed):
         self.rotSpeed = speed
 
     def getRotSpeed(self):
         return self.rotSpeed
-        
+
     def lock(self):
         if self.state != "Still":
             self.demand("Still")
-        
+
     def enterChase(self, target=None):
         if not target:
             target = hidden.attachNewNode('target')
             target.setPos(self.getPoint())
-            
+
         pos = target.getPos()
         theta = angle(self.pet.getPos(), pos) * (math.pi / 180)
         dx = dist * math.cos(theta)
         dy = dist * math.sin(theta)
-        
+
         self.walkToPoint(Point3(pos.getX() - dx, pos.getY() - dy, pos.getZ()))
-        
+
     def exitChase(self):
         if self.__chaseCallback:
             self.__chaseCallback()
             self.__chaseCallback = None
-            
+
         if self.__seq:
             self.__seq.pause()
-            
+
         self.__seq = None
-        
+
     def walkToAvatar(self, av, callback=None):
         if callback:
             self.__chaseCallback = callback
-            
+
         self.demand("Chase", av)
-