#   _*_ coding:utf-8 _*_
from random import randint
import sys
import pygame
from pygame.locals import *
from gameobjects.vector2 import Vector2
import time

__author__ = 'admin'

'''
    螞蟻狀態機(九)
    新目標：增加蜘蛛物件
    1.蜘蛛滿屏遊走
    2.若蜘蛛走進巢穴
    ExploreState中判斷葉子的同時也判斷蜘蛛，再把蜘蛛id繫結到ant物件上即可
    再實現蜘蛛的explore
    想要蜘蛛和ant都共享這個explore的方法，只能將ant的explore方法移至ObjProduct中
    再在Microcosm中增加遍歷所有物件的並使其explore的方法
    還需再處理葉子沒有explore的問題
    在狀態機管理器StateMachine中將obj.name為'leaf'的過濾掉就可以了
    問題：怎麼才能使得蜘蛛擁有wait()而不擁有seek等狀態
    解決：使用了最不想用的辦法，蜘蛛另存一個狀態集合，在蜘蛛和螞蟻共享的狀態機上加以判斷當前物件是螞蟻還是蜘蛛
'''
SCREEN_SIZE = (640, 480)
NEST_POSITION = (320, 240)
NEST_SIZE = 100.

WHITE = (255, 255, 255)

clock = pygame.time.Clock()


class Microcosm(object):
    def __init__(self):
        self.objects_dict = {}
        self.capricious_dict = {}
        self.obj_id = 0
        self.capricious_list = []

    def addObj(self, obj):
        #   在changeState方法中需要傳入一個包含所有螞蟻物件的列表，這個列表中也包含有未被拾取的葉子
        self.capricious_list.append(obj)
        #   用於儲存程式執行之後生成的所有物件及其對應的id
        self.objects_dict[self.obj_id] = obj
        #   道理同objects_dict，只不過該dict會不斷的被新增和刪除，主要是確定哪些葉子允許被螞蟻seek
        self.capricious_dict[self.obj_id] = obj
        #   是在這個位置為物件附上id屬性的，下面刪除字典元素時要用到這個id
        obj.id = self.obj_id
        self.obj_id += 1

    def getObj(self, obj_id):
        return self.objects_dict[obj_id]

    def get_closeTo_obj(self, name, position, range=50):
        for obj in self.capricious_dict.values():
            if obj.name == name:
                distance = position.get_distance_to(obj.position)
                if distance <= range:
                    return obj
        return None

    #   繪製方法存在這裡，每個繼承的子類都在這裡繪製，無需在每個物件類中再繪製了
    #   每個物件類中只需要實時的變更其位置即可
    def draw(self, surface):
        surface.fill(WHITE)
        pygame.draw.circle(surface, (200, 255, 200), NEST_POSITION, int(NEST_SIZE))
        for obj in self.objects_dict.values():
            obj.draw(surface)

class ObjProduct(object):
    def __init__(self, microcosm, name, path):
        self.microcosm = microcosm
        self.name = name
        self.image_path = path
        self.image = pygame.image.load(self.image_path).convert_alpha()
        self.state = 0
        self.fsm = None
        self.id = 0
        self.speed = 0
        self.position = Vector2(0, 0)
        self.destination = Vector2(0, 0)

    def bind(self, state, fsm):
        self.fsm = fsm
        self.state = state

    def draw(self, surface):
        x, y = self.position
        w, h = self.image.get_size()
        surface.blit(self.image, (x - w / 2, y - h / 2))

    def explore(self):
        print("[%s-%d]探索中....." % (self.name, self.id))
        distance = self.destination - self.position
        #   獲取此時螞蟻距離目標點間的向量長度(即兩點間的實際距離)
        x = self.position.get_distance_to(self.destination)
        #   獲取單位向量，即每次螞蟻移動的向量
        heading = distance.normalise()
        #   如果螞蟻再移動單位向量就會越過目標點
        if x <= heading.get_length():
            print("[%s-%d]到達目的地了....前往下一個點" % (self.name, self.id))
            # self.destination = Vector2(randint(0, SCREEN_SIZE[0] // 2), randint(0, SCREEN_SIZE[1] // 2))
            return True
        else:
            self.position += heading

class Spider(ObjProduct):
    def __init__(self, microcosm, name, path):
        ObjProduct.__init__(self, microcosm, name, path)
        self.position = Vector2(randint(0, SCREEN_SIZE[0] // 2), randint(0, SCREEN_SIZE[1] // 2))

    def draw(self, surface):
        ObjProduct.draw(self, surface)

    def wait(self):
        print("[%s-%d]停頓下，思考人生....." % (self.name, self.id))
        pygame.time.delay(10)

class Leaf(ObjProduct):
    def __init__(self, microcosm, name, path):
        ObjProduct.__init__(self, microcosm, name, path)
        self.position = Vector2(randint(0, SCREEN_SIZE[0] // 2), randint(0, SCREEN_SIZE[1] // 2))

    def draw(self, surface):
        ObjProduct.draw(self, surface)

class Ant(ObjProduct):
    def __init__(self, microcosm, name, path):
        ObjProduct.__init__(self, microcosm, name, path)
        self.position = Vector2(100, 100)
        self.destination = Vector2(randint(0, SCREEN_SIZE[0] // 2), randint(0, SCREEN_SIZE[1] // 2))
        #   這裡讓leaf_id為None，單純就是不想給它一個數字而已，避免這個預設值作為Key使用時報錯
        self.leaf_id = None

    def draw(self, surface):
        ObjProduct.draw(self, surface)

    def wait(self):
        print("[%s-%d]停頓下，思考人生....." % (self.name, self.id))
        pygame.time.delay(10)

class State(object):
    def exec(self, obj):
        pass

    def exit(self, obj):
        pass


class ExploreState(State):
    def exec(self, obj):
        #   決定探索過程中觸發wait的頻率
        if randint(1, 1000) == 1:
            #   訊號置為0
            obj.state = 0
        else:
            if obj.name == 'ant':
                #   判斷當前螞蟻物件附近範圍內是否有葉子存在，並獲取這個葉子物件
                leaf_ = obj.microcosm.get_closeTo_obj('leaf', obj.position)
                #   如果有這樣的葉子物件
                if leaf_ is not None:
                    #   為當前螞蟻物件新增該目標葉子id屬性(將該葉子繫結到該螞蟻上，方便呼叫)
                    obj.leaf_id = leaf_.id
                    #   訊號置為seek
                    obj.state = 2
                else:
                    #   附近沒有葉子就執行explore
                    if obj.explore():
                        obj.destination = Vector2(randint(0, SCREEN_SIZE[0] // 2), randint(0, SCREEN_SIZE[1] // 2))
            elif obj.name == 'spider':
                if obj.explore():
                    obj.destination = Vector2(randint(0, SCREEN_SIZE[0] // 2), randint(0, SCREEN_SIZE[1] // 2))


class WaitSate(State):
    def exec(self, obj):
        #   執行wait方法
        obj.wait()
        #   訊號置為1，使得螞蟻再動起來
        obj.state = 1


class SeekState(State):
    def exec(self, obj):
        #   當前螞蟻物件是否綁定了leaf_id屬性(這點可以說明螞蟻附近是否有葉子)
        if obj.leaf_id is not None:
            #   當前螞蟻已經有了葉子目標，capricious_dict中該葉子還未被刪除，說明未被其他螞蟻搶先拾取
            if obj.leaf_id in obj.microcosm.capricious_dict.keys():
                print("[%s-%d]發現目標葉子..走過去" % (obj.name, obj.id))
                #   通過已知的葉子id獲取對應的葉子物件
                leaf_ = obj.microcosm.getObj(obj.leaf_id)
                #   將葉子的位置當做螞蟻本次行為的終點
                obj.destination = leaf_.position
                if obj.explore():
                    print("[%s-%d]已達到目標葉子" % (obj.name, obj.id))
                    #   將該葉子移出capricious_dict中，起到不可被seek的作用
                    obj.microcosm.capricious_dict.pop(leaf_.id)
                    obj.microcosm.capricious_list.remove(leaf_)
                    #   將巢穴範圍內隨機的一個位置當做螞蟻TransState的終點
                    obj.destination = Vector2(NEST_POSITION) + Vector2(randint(-40, 40), randint(-40, 40))
                    obj.state = 3
            else:
                #   當前螞蟻鎖定的葉子被其他螞蟻搶先拾取
                print("[%s-%d]的葉子被別的螞蟻搶先拾取...." % (obj.name, obj.id))
                obj.state = 1
        else:
            #   當前螞蟻附近沒有葉子了，執行探索
            obj.state = 1

class TransState(State):
    def exec(self, obj):
        leaf_ = obj.microcosm.getObj(obj.leaf_id)
        print("[%s-%d]拾起葉子，走回巢穴..." % (obj.name, obj.id))
        #   通過螞蟻當前的位置確定其拾取到的葉子的位置-----》待優化
        leaf_.position = Vector2(obj.position)
        #   獲取此時螞蟻起點->終點的向量
        distance = obj.destination - obj.position
        #   獲取此時螞蟻距離目標點間的向量長度(即兩點間的實際距離)
        x = obj.position.get_distance_to(obj.destination)
        #   獲取單位向量，即每次螞蟻移動的向量
        heading = distance.normalise()
        #   如果螞蟻再移動單位向量就會越過目標點
        if x <= heading.get_length():
            # print("[Ant-%d]已回到巢穴之中" % obj.id)
            #   將該螞蟻繫結的葉子id置為None
            obj.leaf_id = None
            #   訊號置為1，繼續探索
            obj.state = 1
        else:
            obj.position += heading
            #   還未將葉子運回巢穴之內，繼續trans
            obj.state = 3

class StateMachine(object):
    def __init__(self):
        #   狀態集合
        self.states_Ant = {0: WaitSate(), 1: ExploreState(), 2: SeekState(), 3: TransState()}
        self.states_Spider = {0: WaitSate(), 1: ExploreState()}

    #   改變狀態
    def changeState(self, objs):
        for obj in objs:
            #   這裡先留著吧，考慮下state是否有為None的必要
            if obj.state is None:
                return
            else:
                if obj.name == 'leaf':
                    #   無狀態，不做處理，其實也可以在外層先過濾掉leaf物件
                    pass
                elif obj.name == 'spider':
                    print("name[%s]--state[%d]" % (obj.name, obj.state))
                    newFsm = self.states_Spider[obj.state]
                    newFsm.exec(obj)
                else:
                    print("name[%s]--state[%d]" % (obj.name, obj.state))
                    newFsm = self.states_Ant[obj.state]
                    newFsm.exec(obj)

def checkForOut():
    for event in pygame.event.get():
        if event.type == 12:
            sys.exit()
        if event.type == 2:
            if event.key == 27:
                exit()


pygame.init()
screen = pygame.display.set_mode(SCREEN_SIZE, 0, 32)

micr = Microcosm()
sm = StateMachine()
for i in range(3):
    ant = Ant(micr, 'ant', r"E:\PycharmProjects\PGStudy\resource\ant.png")
    ant.bind(0, sm.states_Ant[0])
    micr.addObj(ant)

for i in range(1):
    spider = Spider(micr, 'spider', r"E:\PycharmProjects\PGStudy\resource\spider.png")
    micr.addObj(spider)

while True:
    checkForOut()
    #   生出葉子
    if randint(1, 100) == 1:
        leaf = Leaf(micr, 'leaf', r"E:\PycharmProjects\PGStudy\resource\leaf.png")
        micr.addObj(leaf)
    #   將繪製方法全部封裝，每次迴圈重刷螢幕上所有物件
    micr.draw(screen)
    sm.changeState(micr.capricious_list)
    pygame.display.update()
    pygame.time.delay(10)