def __init__(self, health, damage, energy, tag, exploration_factor=1):
self.health = health
self.max_health = health
self.energy = energy
self.max_energy = energy
self.damage = damage
self.dead = False
self.dodge = 0.2
self.weaken = 0
self.protection = 0
self.stunned = False
self.critical = 0.1
self.playerCurrTurn = 0
self.spells = []
self.buffs = []
self.spells.append(Spell.Attack(0, 100, 50))
#self.spells.append(Spell.Heal(2,200,200))
self.spells.append(Spell.LongMissHeal(6, 300, 20, 4))
self.spells.append(Spell.Charge(0, 0, 600))
self.spells.append(Spell.Stun(7, 200, 3))
###Player
self.tag = tag
self.exp_factor = exploration_factor
self.exploration_rate = exploration_factor
#self.exploration_rate = 1.0 # Initial exploration rate
self.exploration_delta = 1.0 / 100 # Shift from exploration to explotation
###Agent
self.epsilon = 0.95 #0.9
#od 50F3 do 55F3 self.alpha = 0.9
self.alpha = 0.9
self.prev_state = [100, 100, 0] #state-[playerHealth%,enemyHealth%]
self.state = [100, 100, 0]
self.queue = myQueue(3)
def test_Queue_viewEmpty(self):
""" view() method prints warning for empty queue.
"""
q = myQueue()
temp_stdout = StringIO()
with contextlib.redirect_stdout(temp_stdout):
q.view()
output = temp_stdout.getvalue().strip()
assert output == "Queue is empty."
def test_Queue_front(self):
""" Enqueue three items. front() method returns first item enqueued. Size remains unchanged.
"""
q = myQueue()
q.enqueue(1)
q.enqueue(2)
q.enqueue(3)
size = q.size()
self.assertEqual(1, q.front())
self.assertEqual(size, q.size())
def test_Queue_enqueueDequeue(self):
""" Enqueue three items, Dequeue one. Item returned is first item enqueued. Size is now 2.
"""
q = myQueue()
q.enqueue(1)
q.enqueue(2)
q.enqueue(3)
self.assertEqual(3, q.size())
result = q.dequeue()
self.assertEqual(result, 1)
self.assertEqual(2, q.size())
def findInsertLocation(self):
if self.isEmpty():
return self.root
q = myQueue(LinkedList.Node(self.root))
while q.is_empty() == False:
n: BinarySearchTree.Node = q.dequeue().data
if n.hasLeft() and n.hasRight():
q.enqueue(LinkedList.Node(n.left))
q.enqueue(LinkedList.Node(n.right))
else:
return n
def bfs(self, startVertex, main_surface):
q = myQueue()
q.enqueue(LinkedList.Node(startVertex))
startVertex.visited = True
while not q.is_empty():
v = q.dequeue().data
neighbours = gg.neighbours(v)
for n in neighbours:
if not n.visited:
n.visited = True
q.enqueue(LinkedList.Node(n))
showGrid(main_surface, self)
def test_Queue_dequeueFromEmptyQueue(self):
""" Attempt to dequeue from empty queue. Warning message is printed. return value is None.
"""
q = myQueue()
q.enqueue(1)
q.enqueue(2)
q.enqueue(3)
q.dequeue()
q.dequeue()
q.dequeue()
temp_stdout = StringIO()
with contextlib.redirect_stdout(temp_stdout):
result = q.dequeue()
output = temp_stdout.getvalue().strip()
assert output == "Cannot dequeue from an empty queue."
self.assertEqual(result, None)
def test_Queue_newEmpty(self):
""" is_empty() method returns True for new queue.
"""
q = myQueue()
self.assertTrue(q.is_empty())
t1 = time.perf_counter()
frame_rate = 500 / (t1 - t0)
t0 = t1
main_surface.fill((255, 255, 255))
if toggleFrameRateDisplay:
the_text = my_font.render(
"Frame = {0}, rate = {1:.2f} fps".format(
frame_count, frame_rate), True, (0, 0, 0))
main_surface.blit(the_text, (10, 30))
if start:
startVertex = gg.vertices.head
for i in range(SQUARE_SIZE * GRID_VERTEX_SIZE + GRID_VERTEX_SIZE):
startVertex = startVertex.next
q = myQueue()
q.enqueue(LinkedList.Node(startVertex))
startVertex.visited = True
while not q.is_empty():
v = q.dequeue().data
neighbours = gg.neighbours(v)
for n in neighbours:
if not n.visited:
n.visited = True
q.enqueue(LinkedList.Node(n))
main_surface.fill((255, 255, 255))
showGrid(main_surface, gg)
# pygame.time.delay(1)
pygame.display.update()
# fpsClock.tick(FPS)
self._content.append(v)
self._current = self._current + 1
else:
print('The queue is full')
def get(self):
if self._content:
self._current = self._current - 1
return self._content.pop(0)
else:
print('The queue is empty')
def isEmpty(self):
if not self._content:
return True
else:
return False
def isFull(self):
if self._current == self._size:
return True
else:
return False
if __name__ == '__main__':
print('Please use me as a module.')
import myQueue
q = myQueue.myQueue()
def test_StackEmpty_peek(self):
""" front() method value is None for empty queue."""
s = myQueue()
self.assertIsNone(s.front())
Thread.__init__(self)
self.functionName = functionName
self.params1 = params1
self.params2 = params2
self.start()
def run(self):
try:
func = getattr(theHelp, self.functionName)
if self.params2 == None:
func(self.params1)
else:
func(self.params1, self.params2)
except queue.Full:
time.sleep(.00001)
fileName = 'clip.mp4'
# shared queues
lock = threading.Lock()
extractionQueue = myQueue.myQueue(10, lock)
grayscaleQueue = myQueue.myQueue(10, lock)
theHelp.finished1 = False
theHelp.finished2 = False
t1 = ConsProdThread('extractFrames', params1=fileName, params2=extractionQueue)
t2 = ConsProdThread('grayScale',
params1=extractionQueue,
params2=grayscaleQueue)
t3 = ConsProdThread('displayFrames', params1=grayscaleQueue)
while cnt < k:
mstack.push(queue.dequeue())
cnt += 1
while not mstack.isEmpty():
queue.enqueue(mstack.pop())
totSize = len(queue.queueList)
print(totSize)
for x in range(totSize - k):
queue.enqueue(queue.dequeue())
#testing our logic
queue = myQueue()
queue.enqueue(1)
queue.enqueue(2)
queue.enqueue(3)
queue.enqueue(4)
queue.enqueue(5)
queue.enqueue(6)
queue.enqueue(7)
queue.enqueue(8)
queue.enqueue(9)
queue.enqueue(10)
print("the queue before reversing:")
print(queue.queueList)
reverseK(queue, 10)
print("the queue after reversing:")
print(queue.queueList)
def test_Queue_enqueueSize(self):
""" Enqueue one item onto new Queue. Size is now 1.
"""
q = myQueue()
q.enqueue(1)
self.assertEqual(1, q.size())
with open(imgname, "wb") as pic:
pic.write(req.content)
print t.getName() + " --- " + url
except Exception as e:
print "***"
print e
print url
print "-------------------"
if __name__ == "__main__":
keyWord = raw_input("请输入百度图片搜索关键字：")
pages = raw_input("请输入搜索页数：")
threads = raw_input("请输入下载线程数量：")
cwd = os.getcwd()
imgDir = imgPath + keyWord
if not os.path.exists(imgDir):
os.mkdir(imgDir)
os.chdir(imgDir)
st = time.time()
proxies = proxy_list()
queue = Queue.Queue()
spider = Spider(queue, keyWord, pages)
spider.url_text()
my_queue = myQueue(queue, int(threads), downImg, proxies)
my_queue.startWork()
et = time.time()
print "用时：" + str(et - st)
def BFS_Move_Two(self,
move_one_ok=False,
is_generate=False,
equation_true=None):
def list_add(list_1):
list_2 = cur_state[-1]
from operator import add
return list(map(add, list_1, list_2))
# state_switch_flag_num
# state_switch_flag_op
if is_generate:
queue = myQueue(equation_true + [[0, 0]])
else:
queue = myQueue(self.equation + [[0, 0]])
ans = []
while queue.length() > 0:
# queue.show()
cur_state = queue.outqueue()
if cur_state[-1] != [2, 0]:
state_switch_list_num = self.next_state_search(cur_state[-1],
is_num=True)
state_switch_list_op = self.next_state_search(cur_state[-1],
is_num=False)
for idx, element in enumerate(cur_state[:-1]):
try:
num = int(element)
digits = self.num_2_digit(num)
for digit_idx in range(len(digits)):
for state_pos in state_switch_list_num:
queue = self.state_switch(
getattr(self, state_pos),
list_add(
self.state_switch_flag_num[state_pos]),
cur_state,
idx,
queue,
op=None,
digits=digits,
digit_idx=digit_idx)
except ValueError as opError:
for state_pos in state_switch_list_op:
queue = self.state_switch(
getattr(self, state_pos),
list_add(self.state_switch_flag_op[state_pos]),
cur_state,
idx,
queue,
op=element)
if (move_one_ok and cur_state[-1] == [1, 0]) or (
not move_one_ok and cur_state[-1] == [2, 0]):
if self.equation_legal(cur_state[:-1]) and self.equation_hold(
cur_state[:-1]) and not is_generate:
ans.append(cur_state[:-1])
if self.equation_legal(
cur_state[:-1]) and not self.equation_hold(
cur_state[:-1]) and is_generate:
ans.append(cur_state[:-1])
return ans
def BFS_Move_One(self, is_generate=False, equation_true=None):
if is_generate:
queue = myQueue(equation_true + ['Init'])
else:
queue = myQueue(self.equation + ['Init'])
ans = []
while queue.length() > 0:
cur_state = queue.outqueue()
if cur_state[-1] == 'Init':
for idx, element in enumerate(cur_state[:-1]):
try:
num = int(element)
digits = self.num_2_digit(num)
for digit_idx in range(len(digits)):
queue = self.state_switch(
self.num_switch_stick_stable,
'Done',
cur_state,
idx,
queue,
op=None,
digits=digits,
digit_idx=digit_idx)
queue = self.state_switch(
self.num_switch_stick_change_sub,
'Add',
cur_state,
idx,
queue,
op=None,
digits=digits,
digit_idx=digit_idx)
queue = self.state_switch(
self.num_switch_stick_change_add,
'Sub',
cur_state,
idx,
queue,
op=None,
digits=digits,
digit_idx=digit_idx)
except ValueError as opError:
queue = self.state_switch(self.op_switch_stick_stable,
'Done',
cur_state,
idx,
queue,
op=element)
queue = self.state_switch(
self.op_switch_stick_change_sub,
'Add',
cur_state,
idx,
queue,
op=element)
queue = self.state_switch(
self.op_switch_stick_change_add,
'Sub',
cur_state,
idx,
queue,
op=element)
if cur_state[-1] == 'Add':
for idx, element in enumerate(cur_state[:-1]):
try:
num = int(element)
digits = self.num_2_digit(num)
for digit_idx in range(len(digits)):
queue = self.state_switch(
self.num_switch_stick_change_add,
'Done',
cur_state,
idx,
queue,
op=None,
digits=digits,
digit_idx=digit_idx)
except ValueError as opError:
queue = self.state_switch(
self.op_switch_stick_change_add,
'Done',
cur_state,
idx,
queue,
op=element)
if cur_state[-1] == 'Sub':
for idx, element in enumerate(cur_state[:-1]):
try:
num = int(element)
digits = self.num_2_digit(num)
for digit_idx in range(len(digits)):
queue = self.state_switch(
self.num_switch_stick_change_sub,
'Done',
cur_state,
idx,
queue,
op=None,
digits=digits,
digit_idx=digit_idx)
except ValueError as opError:
queue = self.state_switch(
self.op_switch_stick_change_sub,
'Done',
cur_state,
idx,
queue,
op=element)
if cur_state[-1] == 'Done':
if self.equation_legal(cur_state[:-1]) and self.equation_hold(
cur_state[:-1]) and not is_generate:
ans.append(cur_state[:-1])
if self.equation_legal(
cur_state[:-1]) and not self.equation_hold(
cur_state[:-1]) and is_generate:
ans.append(cur_state[:-1])
return ans
import sys, socket, os, myQueue, threading, datetime
import OrderedSet as oSet
users = {}
jQueue = myQueue.myQueue()
startTime = datetime.datetime.now()
logName = "%d_%d_%d_%d_%d_log.txt" % (startTime.month, startTime.day, startTime.year, startTime.hour, startTime.minute)
logList = []
try:
logFile = open(logName,"w")
except:
print "ERR: Failed to create log"
def menuPrint(other):
#Used for status messages
#Overwrites the existing line (Enter a Command), prints the message,
#then reprints the prompt on the next line
sys.stdout.write('\r' + other + "\nEnter a Command: ")
sys.stdout.flush()
#Using sys.stdout to avoid trailing newline. Flushing to ensure it all gets out
def checkUsers(uName, conn):