�� . �� : http://kodomo.cmm.msu.ru/trac/snake/browser/snake.py?rev=44
�� : Unknown
�� : Mon Apr 11 14:38:43 2016
��: UTF-8

snake.py ? Python Battle

Context Navigation

source: snake.py @ 44:a7e53eb3f54d

Revision 44:a7e53eb3f54d, 4.1 KB checked in by Daniil Alexeyevsky <me.dendik@?>, 5 years ago (diff)
snake.py: added some (ugly) docstrings, closes #7

Line	�
1	"""Guts of snakes."""
2
3	import�engine
4
5	def�preprocess(line):
6	� � """Remove comments and junk spaces from line of snake definition file."""
7	� � if�'//'�in�line:
8	� � � � line =�line[:line.index('//')]
9	� � line =�line.rstrip()
10	� � return�line
11
12	class�Snake(object):
13	� � """Snakes.
14
15	� � Attributes:
16
17	� � - `cells` -- list of cells belonging to the snake The first of these cells
18	� � � becomes head, the last one becomes tail, the rest ar body. If snake has
19	� � � only one cell, it is tail.
20	� � - `color` -- color of snake
21	� � - `rules` -- a list of Rule objects
22	� � """
23
24	� � def�__init__�(self,�cells,�color):
25	� � � � self.cells =�cells
26	� � � � self.color =�color
27	� � � � self.rules =�[]
28
29	� � def�load�(self,�file):
30	� � � � """Load snake description from file.
31	� � � �
32	� � � � See program design docs for file syntax.
33	� � � � """
34	� � � � magic,�name =�preprocess(file.readline()).split(' ',�1)
35	� � � � assert�magic ==�"snake",�"This is not snake file"
36	� � � � while�True:
37	� � � � � � line =�preprocess(file.readline())
38	� � � � � � if�line ==�'end':
39	� � � � � � � � break
40	� � � � � � assert�line ==�'',�"Rules must be separated by empty lines"
41	� � � � � � self.rules.append(Rule().load(file))
42
43	� � def�fill�(self):
44	� � � � """Mark every cell in `self.cells` as belonging to self."""
45	� � � � for�cell in�self.cells:
46	� � � � � � cell.snake =�self
47	� � � � snake.cells[0].type =�'head'
48	� � � � snake.cells[1:-1].type =�'body'
49	� � � � snake.cells[-1].type =�'tail'
50	� � � � return
51
52	class�Rule(object):
53	� � """Rule defining possible behaviour of snake."""
54
55	� � codes =�{
56	� � � � 'h':�'head',
57	� � � � 'b':�'body',
58	� � � � 't':�'tail',
59	� � � � '#':�'wall',
60	� � � � ' ':�'any',
61	� � � � '-':�'empty',
62	� � }
63
64	� � def�__init__�(self,�snake):
65	� � � � self.snake =�snake
66	� � � � self.direction =�(1,�0)
67	� � � � self.pattern =�{}
68
69	� � def�load�(self,�file):
70	� � � � """Load rule definition from file. Ignore any leading empty lines."""
71	� � � � y =�0
72	� � � � for�line in�file:
73	� � � � � � line =�preprocess(line)
74	� � � � � � if�y ==�0�and�line ==�'':
75	� � � � � � � � continue
76	� � � � � � if�y ==�7:
77	� � � � � � � � break
78	� � � � � � assert�len(line)�==�8,�"Rule lines must be exactly 7 chars long"
79	� � � � � � assert�line[-1]�==�';',�"Rule lines must end with semicolon"
80	� � � � � � for�x,�char in�enumerate(line[:8]):
81	� � � � � � � � self.parse_cell(x,�y,�char)
82	� � � � � � y +=�1
83
84	� � def�parse_cell(self,�x,�y,�char):
85	� � � � """Parse definition of cell in rule file.
86
87	� � � � Cell is defined by one character.
88	� � � � """
89	� � � � assert�char.lower()�in�self.codes,�"Illegal symbol in rule: %s"�%�char
90	� � � � cell =�engine.Cell(x,�y,�None)
91	� � � � if�char in�'htb':
92	� � � � � � if�char.islower():
93	� � � � � � � � cell.snake =�'my'
94	� � � � � � else:
95	� � � � � � � � cell.snake =�'enemy'
96	� � � � if�char ==�'h':
97	� � � � � � assert�(x,�y)�==�(3,�3),�"Own head must in the center of rule"
98	� � � � if�(x,�y)�==�(3,�3):
99	� � � � � � assert�char ==�'h',�"In the center of rule must be own head"
100	� � � � cell.type =�self.codes[char.lower()]
101	� � � � self.pattern[x,�y]�=�cell
102
103	� � def�applies�(self,�field,�x,�y):
104	� � � � """True if the rule applies in the field at position (x,y)."""
105	� � � � for�px,�fx in�zip(range(7),�range(x -�3,�x +�4)):
106	� � � � � � for�py,�fy in�zip(range(7),�range(y -�3,�y +�4)):
107	� � � � � � � � if�fx,�fy in�field:
108	� � � � � � � � � � if�field[fx,�fy]�!=�self.pattern[px,�py]:
109	� � � � � � � � � � � � return�False
110	� � � � � � � � else:
111	� � � � � � � � � � if�self.pattern[px,�py].type !=�'any':
112	� � � � � � � � � � � � return�False
113	� � � � return�True
114
115	� � def�rotate�(self,�rot):
116	� � � � """Rotate rule pattern `rot` times counterclockwise."""
117	� � � � for�i in�range(((rot %�4)�+�4)�%�4):
118	� � � � � � self.rotate_ccw()
119
120	� � def�rotate_ccw(self):
121	� � � � """Rotate rule pattern one time counterclockwise."""
122	� � � � pattern =�{}
123	� � � � for�x in�range(7):
124	� � � � � � for�y in�range(7):
125	� � � � � � � � pattern[y,�6�-�x]�=�self.pattern[x,�y]
126	� � � � self.pattern =�pattern
127	� � � � x,�y =�self.direction
128	� � � � self.direction =�y,�-x
129
130	# vim: set ts=4 sts=4 sw=4 et:

Note: See TracBrowser for help on using the repository browser.

Download in other formats: