""" mgoal.py
 Copyright (C) 1998 Aloril
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
"""

import whrandom
import const
from goal import goal
from house import house
from mind import *

#goals for minds

def false(me): return 0
def true(me): return 1

############################ FIND HOME ####################################

def is_suitable_place_for_home(me):
    "place is suitable is there is no homes in 100m radius"
    count=len(me.mem.recall_place(me.get_xyz(),100.0))
    return count==0

def find_place(me):
    "find place for home: wander randomly"
    (x,y,z)=me.get_xyz()
    r=lambda :whrandom.uniform(-50,50)
    return [event("move",what=me,loc=(x+r(),y+r(),z+r()))]

find_place_for_home=goal("find place for home not too near or far from others",
                         is_suitable_place_for_home,
                         [find_place])

def make_home(me):
    "Starts home building"
    me.add_knowledge("xyz","home",me.get_xyz())
    return [event("make",what="house", what_desc="home", loc=me.get_xyz())]

def have_home(me):
    "Do I have home?"
    return me.things.has_key('house')

find_home=goal("find place for home and make it",
               have_home,
               [find_place_for_home,make_home])

############################ BUILD HOME ####################################

def have_build_home(me):
    "Do I have home that is fully build?"
    t=me.things.get('house')
    if t: return t[0].status>=1.0-const.fzero

def build_house(me):
    "Build my home"
    h=me.things['house'][0]
    return [event("change",what=h,amount=0.1)]

build_home=goal("find place for home and build it",
                have_build_home,
                [find_home, build_house])

########################## MAKE LOTS OF SOMETHING #################################

class make_amount(goal):
    def __init__(self, what, amount, what_desc="some thing", place=None):
        goal.__init__(self,"make certain amount of things",
                      self.are_all_done,
                      [move_me(place),self.do_all])
        self.what=what
        self.amount=amount
        self.what_desc=what_desc
        self.vars=["what","amount"]
    def are_all_done(self, me):
        t_list=me.find_thing(self.what)
        if len(t_list)<self.amount: return 0
        for t in t_list:
            if t.status<1.0-const.fzero: return 0
        return 1
    def do_all(self, me):
        for t in me.find_thing(self.what):
            if t.status<1.0-const.fzero: 
                return [event("change",what=t,amount=0.1)]
        return [event("make",what=self.what,what_desc=self.what_desc)]

############################ NOT YET IMPLEMENTED ####################################

class nyi(goal):
    def __init__(self, desc):
        goal.__init__(self,desc,
                      lambda self:0,
                      [self.not_yet_implemented])
        self.vars=["desc"]
    def not_yet_implemented(self, me):
        #CHEAT! (make it so that it asks other people for knowledge)
        return [event("NYI",desc=self.desc)]

############################ MOVE ME ####################################

class move_me(goal):
    def __init__(self, loc):
        goal.__init__(self,"move me to certain place",
                      self.am_I_at_loc,
                      [self.move_to_loc])
        self.loc=loc
        self.vars=["loc"]
    def am_I_at_loc(self, me):
        if not self.loc: return 1
        #CHEAT!: cludge!
        if type(self.loc)==LambdaType: self.loc=self.loc(me)
        #mind uses sometimes strings known only to him/her
        if type(self.loc)==StringType: return me.place==self.loc
        return me.get_loc()==self.loc
    def move_to_loc(self, me):
        return [event("move", what=me, loc=self.loc)]

############################ MOVE THING ####################################

class move_it(goal):
    def __init__(self, what, loc):
        goal.__init__(self,"move this to certain place",
                      self.is_it_at_loc,
                      [self.move_it_to_loc])
        self.what=what
        self.loc=loc
        self.vars=["what","loc"]
    def is_it_at_loc(self, me):
        #CHEAT!: cludge
        if type(self.what)==StringType: self.what=me.things[self.what][0]
        return self.what.get_loc()==self.loc
    def move_it_to_loc(self, me):
        return [event("move", what=self.what, loc=self.loc)]

############################ MOVE THING TO ME ####################################

class move_it_into_me(goal):
    def __init__(self, me, what):
        if type(what)==StringType:
            goal.__init__(self,"move this thing to my inventory (string)",
                          self.is_it_with_me,
                          [move_me(lambda me,what=what:me.things[what][0].get_loc()),
                           move_it(what,me)])
        else:
            goal.__init__(self,"move this thing to my inventory (class)",
                          self.is_it_with_me,
                          [move_me(what.get_loc()),
                           move_it(what,me)])
        self.what=what
        self.vars=["what"]
    def is_it_with_me(self, me):
        #CHEAT!: cludge
        if type(self.what)==StringType: self.what=me.things[self.what][0]
        return self.what.get_loc()==me

############################ IMAGINARY TASK ####################################

class imaginary(goal):
    def __init__(self, desc, time, place):
        goal.__init__(self,desc,false,[move_me(place),self.imaginary],time)
        self.vars=["desc"]
    def imaginary(self,me):
        return [event("imaginary",desc=self.desc)]

############################ GET KNOWLEDEGE ABOUT THING #############################

class get_knowledge(goal):
    def __init__(self, me, what):
        goal.__init__(self,"get knowledge about thing by name",
                      self.do_I_know_about_this,
                      [nyi("Try another task or try asking around!")])
        self.what=what
        self.vars=["what"]
    def do_I_know_about_this(self, me):
        return me.get_knowledge("place",self.what)

############################ BUY KNOWN THING ##############################

class buy_thing(goal):
    def __init__(self, me, what):
        #CHEAT!: doesn't work for static goals ;-(
        #goal systems needs redesign
        place=me.get_knowledge("place",what)
        goal.__init__(self,"buy thing by name (I am at shop)",
                      self.do_I_have_it,
                      [move_me(place),
                       self.buy_it])
        self.what=what
        self.vars=["what"]
    def do_I_have_it(self, me):
        return me.things.has_key(self.what)
    def buy_it(self, me):
        e=event("say",what=esay("I want to buy "+self.what,
                                verb='buy',subject=self.what))
        #check if I already did this
        if me.mem.recall_event(e,lambda e1,e2:e1.command==e2.command\
                               and e1.what==e2.what):
            return []
        #no I didn't: do it
        return [e]

############################ ACQUIRE THING: BASE ##############################

class acquire(goal):
    def is_it_in_my_inventory(self,me):
        if me.things.has_key(self.what):
            return me.things[self.what][0].get_loc()==me
        return 0

############################ ACQUIRE KNOWN THING ##############################

class acquire_known_thing(acquire):
    def __init__(self, me, what):
        goal.__init__(self,"acquire known thing by name",
                      self.is_it_in_my_inventory,
                      [buy_thing(me,what),
                       move_it_into_me(me,what)])
        self.what=what
        self.vars=["what"]

############################ ACQUIRE THING ####################################

class acquire_thing(acquire):
    def __init__(self, me, what):
        goal.__init__(self,"acquire thing by name",
                      self.is_it_in_my_inventory,
                      [get_knowledge(me,what),
                       acquire_known_thing(me,what)])
        self.what=what
        self.vars=["what"]

############################ TASK WITH PLACE AND TOOL #############################

class task(goal):
    def __init__(self, me, desc, time, place, tool):
        goal.__init__(self,desc,
                      false,
                      [acquire_thing(me,tool),
                       move_me(place),
                       self.do],
                      time)
        self.tool=tool
        self.vars=["tool"]
    def do(self,me):
        return [event("imaginary",desc=self.desc)]

############################ CUT TREES TASK #############################

class cut_something(task):
    def do(self,me):
        return [event("cut",what=me.find_thing(self.tool)[0])]