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

__author__ = 'admin'

'''
    螞蟻狀態機(三)
    實現了狀態機內部訊號自動轉換，不依靠外界訊號
    螞蟻最初為waiting
    轉變為exploring後再判斷是否發現目標葉子，期間穿插waiting(使用隨機數決定發生頻率)
    發現葉子轉為seeking
    達到葉子後轉為exploring，否則繼續seeking
'''

SCREEN_SIZE = (640, 480)
NEST_POSITION = (320, 240)
NEST_SIZE = 100.

WHITE = (255, 255, 255)
pygame.init()

screen = pygame.display.set_mode(SCREEN_SIZE, 0, 32)
clock = pygame.time.Clock()


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

    def addObj(self, obj):
        self.objects_list.append(obj)
        self.objects_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, location, range=50):
        for obj in self.objects_dict.values():
            if obj.name == name:
                distance = location.get_distance_to(obj.location)
                if distance <= range:
                    return obj
        return None


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

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


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

    def draw(self, location):
        screen.blit(self.leaf, location)

    def wait(self):
        self.draw(self.leaf_position)

class Ant(ObjProduct):
    def __init__(self, microcosm, name, path):
        ObjProduct.__init__(self, microcosm, name, path)
        self.ant = self.op
        self.location = Vector2(100, 100)
        self.ant_position = self.location
        self.draw(self.ant_position)
        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, location):
        screen.blit(self.ant, location)

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

    def wait(self):
        print("停頓下，思考人生.....")
        pygame.time.delay(10)
        self.draw(self.ant_position)

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:
            #   判斷當前螞蟻物件附近範圍內是否有葉子存在，並獲取這個葉子物件
            leaf_ = obj.microcosm.get_closeTo_obj('leaf', obj.location)
            #   如果有這樣的葉子物件
            if leaf_ is not None:
                #   為當前螞蟻物件新增該目標葉子id屬性(將該葉子繫結到該螞蟻上，方便呼叫)
                obj.leaf_id = leaf_.id
                #   訊號置為seek
                obj.state = 2
            else:
                #   附近沒有葉子就執行explore
                obj.explore()

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:
            #   通過已知的葉子id獲取對應的葉子物件
            leaf_ = obj.microcosm.getObj(obj.leaf_id)
            print("發現目標葉子..走過去")
            #   將葉子的位置當做螞蟻本次行為的終點
            obj.destination = leaf_.location
            #   獲取此時螞蟻起點->終點的向量
            distance = obj.destination - obj.ant_position
            #   獲取此時螞蟻距離目標點間的向量長度(即兩點間的實際距離)
            x = obj.ant_position.get_distance_to(obj.destination)
            #   獲取單位向量，即每次螞蟻移動的向量
            heading = distance.normalise()
            obj.draw(obj.ant_position)
            #   如果螞蟻再移動單位向量就會越過目標點
            if x <= heading.get_length():
                print("已達到目標葉子")
                #   讓螞蟻吃掉葉子，即在字典和列表中刪除葉子物件，以防止下一次explore時螞蟻距離該葉子還很近再被拉回
                obj.microcosm.objects_dict.pop(leaf_.id)
                obj.microcosm.objects_list.remove(leaf_)
                #   將該螞蟻繫結的葉子id置為None
                obj.leaf_id = None
                #   將訊號置為1，繼續探索
                obj.state = 1
            #   螞蟻還未到達葉子，即還需要繼續走一個heading
            else:
                obj.ant_position += heading
                #   繼續執行seeking
                obj.state = 2
        else:
            #   當前螞蟻附近沒有葉子了，執行探索
            obj.state = 1



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

    #   改變狀態
    def changeState(self, objs):
        for obj in objs:
            #   這裡先留著吧，考慮下state是否有為None的必要
            if obj.state is None:
                return
            else:
                if obj.name == 'leaf':
                    curFsm = self.states[0]
                    curFsm.exec(obj)
                else:
                    print("name[%s]--state[%d]" % (obj.name, obj.state))
                    newFsm = self.states[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()


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

while True:
    checkForOut()
    screen.fill(WHITE)
    pygame.draw.circle(screen, (200, 255, 200), NEST_POSITION, int(NEST_SIZE))
    if randint(1, 500) == 1:
        leaf = Leaf(micr, 'leaf', r"E:\PycharmProjects\PGStudy\resource\leaf.png")
        leaf.bind(0, sm.states[0])
        micr.addObj(leaf)
    sm.changeState(micr.objects_list)
    pygame.display.update()
    pygame.time.delay(10)