Учебный проект № 2

a = wall
b = mine(3)
c = mine(4)
d = pit(4)
e = nope
f = pit(10)

aabcccccccddd-
ffeeeeeaaa---a
-----aaa-----f
------>-------
-----aaa-----f
b----aaa-----f

#!/usr/bin/env python
#coding=utf-8

TEST_BOARD = """
a = wall
b = mine(3)
c = mine(5)
d = pit(4)
e = pit(6)
.
d----a---a----c
---b---b---b---
---------------
a------>------a
----d----------
-----e-----e---
c----a---a----a
"""

class Decor:
    def __init__(self):
        self.impassable = False
        self.mineral = 0
        self.moveCosts = 0

class Wall(Decor):
    def __init__(self, passable = False):
        Decor.__init__(self)
        self.impassable = not bool(passable)

class Mine(Decor):
    def __init__(self, mineral = 1):
        Decor.__init__(self)
        self.mineral = int(mineral)
       
class Pit(Decor):
    def __init__(self, moveCosts = 1):
        Decor.__init__(self)
        self.moveCosts = int(moveCosts)

class DecorDict:

    def __init__(self):
        self.decors = {}
       
    def MakeDecor(self, data):
        decorTypes = {"wall": Wall, "mine": Mine, "pit": Pit}
        if len(data) > 2:
            tag, type, param = data[0], data[1], data[2]
            if type in decorTypes:
                self.decors[tag] = decorTypes[type](param)

class BoardLoader:
   
    def __init__(self, board):
        self.board = board
        self.decorDict = board.decorDict
       
   
    def GetParts(self, text, re_compile):
        result = re_compile.match(text)
        if result:
            return result.groups()

    def ParseDecorPart(self, decorPart):
        import re
       
        objects = decorPart.split('\n')
        re_compile = re.compile(r"""\s*([a-z])\s*=      # var
                                \s*([a-z]+)\s*          # object
                                (?:\(\s*(\d+)\s*\))?\s* # digit""", re.X)
        for s in objects:
            if s:
                parts = re_compile.match(s)
                if parts:
                    self.decorDict.MakeDecor(parts.groups())
   
    def ParseBoardPart(self, boardPart):
        lines = boardPart.split('\n')
        for s in lines:
            if s:
                self.board.SetLine(s)
   
    def MakeBoard(self, data):
        strings = data.split('.')
        if len(strings) > 1:
            self.ParseDecorPart(strings[0])
            self.ParseBoardPart(strings[1])
   
    def MakeTestBoard(self):
        self.MakeBoard(TEST_BOARD)
   
    def Load(self, type):
        self.MakeTestBoard()


class Board:
    decorDict = DecorDict()
   
    def __init__(self):
        self.table = []
   
    def SetLine(self, line):
        lineList = self.TestLine(line)
        if lineList:
            self.table.append(lineList)
           
    def TestLine(self, line):
        return [i for i in line]
       
    def Load(self, type):
        BoardLoader(self).Load(type)
       
if __name__ == '__main__':
    execfile("TestBoard.py")

#!/usr/bin/env python
#coding=utf-8

import unittest
from BoardLoader import *

class TestBoardLoader (unittest.TestCase):

    def setUp(self):
        self.b = Board()
        self.b.Load("test")
       
    def testDictOne(self):
        self.assertTrue(self.b.decorDict.decors['a'].impassable == True)
       
    def testDictTwo(self):
        print self.b.decorDict.decors['e'].moveCosts
        self.assertTrue(self.b.decorDict.decors['e'].moveCosts == 6)
       
    def testBoardOne(self):
        self.assertTrue(self.b.table[0][0] == 'd')

    def testBoardTwo(self):
        self.assertTrue(self.b.table[-1][-1] == 'a')
       
class TestBoardLoader2 (unittest.TestCase):
         
    def testDictOne(self):
        b = BoardLoader(Board())
        b.MakeBoard("")
        self.assertFalse(b.board.table, b.board.table)    
   
       
if __name__ == '__main__':
   
    loadCase = unittest.defaultTestLoader.loadTestsFromTestCase        
    suite = loadCase(TestBoardLoader)
    suite.addTest(loadCase(TestBoardLoader2))
    unittest.TextTestRunner(verbosity = 2).run(suite)
    #unittest.main()
   
    #raw_input("press any key")

drive
====================
a-b
->c
---
====================
move
====================
a-b-
-->-
----
==========
c = mine(3)
====================
turn
====================
a-b-
--V-
----
==========
c = mine(3)
====================
move
====================
a-b-
----
--V-
*--a
==========
c = mine(3)
====================
move
====================
a-b-
----
----
*-Va
*--b
==========
c = mine(3)
====================
_

def ScriptRun(boxReturner):

    index = 0
    commands = ["move"]*5 + ["tr"]
    oldMineral = 0
   
    while True:
   
        dataBox = boxReturner()
       
        if dataBox.mineral > oldMineral:
            oldMineral = dataBox.mineral
            print "Yes! I find new mineral"
       
        yield commands[index]
           
        index += 1
        if index >= len(commands): index = 0

# coding=utf-8

import random

class LevelGenerator:
    ## scale - коэффициент активной части карты
    ## obj_occ - коэффициент вероятности появления игровых обьектов
    ## dividor - делитель вероятности генерации пустот на смежных клетках
    def __init__ (self, wall_char = 'a', space_char = '-', scale = 0.5, obj_occ = 0.5, dividor = 10):
        self.wall_char, self.space_char, self.scale, self.obj_occ, self.dividor = \
        wall_char,      space_char,      scale,      obj_occ,      dividor

    def generate (self, width = 10, height = 10, objects = []):
        self.objects = objects
       
        ## массивы клеток и вероятностей соответственно :
        self.board = [[self.wall_char] * width for _ in [self.wall_char] * height]
        prob = [[0.25] * width for _ in [0.25] * height]
       
        ## первая клетка :
        cell = [random.randint(0, width - 1), random.randint(0, height - 1)]
        x, y = cell
       
        prob[x][y] = 0.0
        self.board[x][y] = self.space_char     
       
        ## отображение направления в координаты :
        dir_map = { '>' : lambda: [x + 1, y],
                    '<' : lambda: [x - 1, y],
                    'v' : lambda: [x, y + 1],
                    '^' : lambda: [x, y - 1] }
                   
        dir_invert = { '>' : '<', '<' : '>', '^' : 'v', 'v' : '^'}
       
        dmapx = lambda arg : dir_map[arg]()[0]
        dmapy = lambda arg : dir_map[arg]()[1]
       
        ## координатные предикаты :
        valid_x = lambda arg : 1 if 0 <= arg < width else 0
        valid_y = lambda arg : 1 if 0 <= arg < height else 0
       
        ## фильтр для списка :
        without = lambda lexem : lambda arg : 1 if arg != lexem else 0
       
        ## цикл линейной пошаговой стадии генерации, i - кол-во шагов :
        i = int(width * height * self.scale)
        while i > 0:
            ## список допустимых направлений :
            valid_directions = filter(without(None), [d if valid_x(dmapx(d)) and valid_y(dmapy(d)) and prob[dmapx(d)][dmapy(d)] else None for d in ['>', '<', 'v', '^']])
                               
            ## выбор одного из направлений и осуществление хода :
            s, roll = 0.0, random.random()
            for d in valid_directions:
                if s <= roll < s + prob[dmapx(d)][dmapy(d)]:               
                    ## уменьшение вероятностей вокруг предыдущей клетки :
                    for dd in filter(without(d), ['>', '<', 'v', '^']):
                        if valid_x(dmapx(dd)) and valid_y(dmapy(dd)):
                            prob[dmapx(dd)][dmapy(dd)] /= self.dividor
                           
                    ## установка координат на новую клетку и её заполнение :
                    x, y = dmapx(d), dmapy(d)
                    prob[x][y] = 0.0
                   
                    self.board[x][y] = self.space_char
                   
                    if objects:
                        s, roll = 0.0, random.random()
                        for obj in objects:
                            if s <= roll <= s + obj[2] * self.obj_occ:
                                self.board[x][y] = obj[0]
                                break
                            else:
                                s += obj[2] * self.obj_occ
                   
                    ## корректировка вероятностей вокруг новой клетки :
                    m = 0.0
                    future_directions = filter(without(dir_invert[d]), ['>', '<', 'v', '^'])
                    for dd in future_directions:
                        if valid_x(dmapx(dd)) and valid_y(dmapy(dd)):
                            m += prob[dmapx(dd)][dmapy(dd)]
                       
                    if m < 0.999:
                        m = (1.0 - m) / len(future_directions)
                        for dd in future_directions:
                            if valid_x(dmapx(dd)) and valid_y(dmapy(dd)):
                                prob[dmapx(dd)][dmapy(dd)] += m                    
                    break
                else:
                    s += prob[dmapx(d)][dmapy(d)]
                    continue
           
            i -= 1
       
    def save (self, filename):
        ## сохранение в файл
        f = open(filename, 'w')
       
        f.write(self.wall_char + ' = wall\n')
       
        for obj in self.objects:
            f.write(obj[0] + ' = ' + obj[1] + '\n')
           
        f.write('.\n')                                 
       
        i = 0
        while i < len(self.board):         
            for c in self.board:
                f.write(c)
            f.write(self.wall_char + '\n')
            i += 1
       
        f.close()      
   
LG = LevelGenerator(dividor = 10, obj_occ = 0.1)
LG.generate(50, 50, [['b', 'mine(3)', 0.5], ['d', 'pit(4)', 0.5]])
LG.save('c:\\test44.txt')

self.wall_char, self.space_char, self.scale, self.obj_occ, self.dividor = \
        wall_char,         space_char,         scale,         obj_occ,       dividor

self.wall_char, self.space_char, self.scale, self.obj_occ, self.dividor = (
        wall_char,         space_char,         scale,         obj_occ,       dividor)