Exemplo n.º 1
0
    def resolve(self, p, noChange=False):
        
        for n in self.newActions.keys():
            if not noChange:
                if random.random() < self.newActions[n]:
                    #~ print "will try ",n
                    if allActions[n].canDo(p):
                        #~ print "try ",n
                        p.action = n
                        return allActions[n].resolve(p)
                
        for r in self.risks.keys():
            if random.random() < self.risks[r][0]:
                
                p.addHealthEvent(r, self.risks[r][1],self.risks[r][2])
                
        for a in self.acquiredKnowledges.keys():
            #~ print a, ".. ",self.acquiredKnowledges[a]
            rr = random.random()
            #~ print rr
            if  rr < self.acquiredKnowledges[a]:
                #~ print "acquiring ",a
                utils.sparseLogs(p.name, p.name +" apprends "+a)
                k = p.knowledges.get(a, 0)
                k += (1-k)*0.1
                p.knowledges[a] = k

        res = {}
        if self.canDo(p):
            for r in self.results.keys():
                res[r] = self.results[r][0] + 0.5*(self.results[r][1] - self.results[r][0])*(random.random() + random.random())
        return res
Exemplo n.º 2
0
    def selectAction(self):
        if self.age < 10.:
            return

        numRandom = 10
        if self.age < 15.:
            numRandom = 1 + int(9*self.age/15.) #les jeunes imitent plus
        if random.randint(0, numRandom) ==0:
            name = random.choice(self.horde.personnes.keys())
            if name != self.name and self.horde.personnes[name].age > 15.:
                act = self.horde.personnes[name].action
                #~ if petiteAction.allActions[act].canDo(self):
                self.action = act
                self.horde.personnes[name].accompagniedBy.append(self.name)
            
                utils.sparseLogs(self.name, "chosen "+str(self.action)+", like "+name)
                return
            
        action = "rester"
        exp = 100.
        for a in self.knownActions.values():
            if petiteAction.allActions[a.name].canDo(self):
                e= dictDist(a.expects({}), self.asked)
                #~ utils.sparseLogs(self.name, a.name+" exp "+str(e))
                if e < exp and random.random() < 0.9:
                    exp = e
                    action = a.name
##                sparseLogs(self.name, "exp "+str(exp))
            
            
        #~ self.action = random.choice()
        self.action = action
Exemplo n.º 3
0
 def addHealthEvent(self, name, gravity, time):
     utils.sparseLogs(self.name, self.name +" subit "+name)
     #~ print self.name +" subit "+name
     h = self.getHealth()
     if h < 1 - gravity:
         if h < random.random()*(1 - gravity):
             self.forme = 0
             if self.male:
                 print "##Unfortunately, ",self.name," died of "+name+". He was ",int(self.age)
             else:
                 print "##Unfortunately, ",self.name," died of "+name+". She was ",int(self.age)
             
     self.sante.append([name,gravity,time ])
Exemplo n.º 4
0
    def resolveAction(self):
        if self.age < 10. + 1/52.:
            return
            
        if self.action != "resolved":
            
            prevAct = self.action
            result = petiteAction.allActions[self.action].resolve(self)
            if self.action is not prevAct:
                utils.sparseLogs(self.name, self.name+ ": in fact, I did "+self.action+" instead of "+prevAct)
                
            utils.sparseLogs(self.name, self.name+ " brings from "+self.action+": "+str(result))
            if not petiteAction.allActions[self.action].dontRemember:
                if self.action not in self.knownActions.keys():
                    self.knownActions[self.action] = petiteActionConnue(self.action)
                    
                self.knownActions[self.action].feedback({}, result)


        
            for r in result.keys():
                #~ self.horde.shelter.addObject(r, result[r])
                self.objects[r] = self.objects.get(r, 0) + result[r]
                for n in utils.needsFromObjects[r].keys():
                    self.horde.askFor(n, - utils.needsFromObjects[r][n]*result[r])
    ##                self.asked[n] = max(-1, self.asked.get(n, 0) - needsFromObjects[r][n]*result[r])
    
                    
            for n in self.accompagniedBy:
                personne = self.horde.personnes[n]
                result = petiteAction.allActions[self.action].resolve(personne, noChange=True)
                utils.sparseLogs(personne.name, personne.name+ " brings from "+self.action+" with "+self.name+": "+str(result))
                if not petiteAction.allActions[self.action].dontRemember:
                    if self.action not in personne.knownActions.keys():
                        personne.knownActions[self.action] = petiteActionConnue(self.action)
                    
                    personne.knownActions[self.action].feedback({}, result)
                
                for r in result.keys():
                    #~ self.horde.shelter.addObject(r, result[r])
                    personne.objects[r] = personne.objects.get(r, 0) + result[r]
                    for n in utils.needsFromObjects[r].keys():
                        self.horde.askFor(n, - utils.needsFromObjects[r][n]*result[r])
                
                personne.action = "resolved"

        self.accompagniedBy = []
        self.action = ""