Class implementation

g2048.py

@@ -2,158 +2,162 @@
 
 import random, copy, curses
 
-def game_logic(l):
+class G2048():
-    oldHash = hash(tuple(l))
+    def __init__(self):
+        self.board = []
 
-    line_active= True
+        self.board_line = 3
-    global moved
+        self.board_size = self.board_line**2
-    merged = False
+        for i in range(self.board_size):
-    while line_active:
+            self.board.insert(i,None)
-        for i in range(board_line-1):
-            if l[i] == None and l[i+1] != None:
-                l.pop(i)
-                l.insert(i+1,None)
-            elif l[i] != None and l[i] == l[i+1] and merged != True:
-                mi=l.pop(i)
-                l.insert(i,int(mi)*2)
     
-                l.pop(i+1)
+        self.moved = False
-                l.insert(i+1,None)
+        self.stdscr = curses.initscr()
 
-                merged = True
+        self.undo = ['u','r']
-                oldHash = hash(tuple(l))
-                moved = True
     
-        newHash = hash(tuple(l))
+        self.up = ['k','w'] #straight
+        self.left = ['h','a'] #straight
+        self.down = ['j','s'] #back
+        self.right = ['l','d'] #back
 
-        if oldHash == newHash:
+        self.line = self.left + self.right
-            # print('Exiting: Boxes didn't move')
+        self.column = self.up + self.down
-            line_active = False
+
+    def game_logic(self, l):
+        oldHash = hash(tuple(l))
+    
+        line_active= True
+        merged = False
+        while line_active:
+            for i in range(self.board_line-1):
+                if l[i] == None and l[i+1] != None:
+                    l.pop(i)
+                    l.insert(i+1,None)
+                elif l[i] != None and l[i] == l[i+1] and merged != True:
+                    mi=l.pop(i)
+                    l.insert(i,int(mi)*2)
+    
+                    l.pop(i+1)
+                    l.insert(i+1,None)
+    
+                    merged = True
+                    oldHash = hash(tuple(l))
+                    self.moved = True
+    
+            newHash = hash(tuple(l))
+    
+            if oldHash == newHash:
+                # print('Exiting: Boxes didn't move')
+                line_active = False
+            else:
+                # print('Repeating: Boxes moved')
+                oldHash = newHash
+                self.moved = True
+    
+        return l
+
+    def reverse(self, rl, m):
+        if m in self.left + self.up:
+            gl = self.game_logic(rl) #k
         else:
-            # print('Repeating: Boxes moved')
+            gl = self.game_logic(rl[::-1])[::-1] #j
-            oldHash = newHash
-            moved = True
-
-    return l
-            
-def movement():
-    stdscr.addstr(10, 0, '\nMove the numbers: ')
-    m = stdscr.getkey()
-    global moved
-    global board
-    global board_reset
-    moved=False
-    board_temp=copy.deepcopy(board)
-
-    undo = ['u','r']
-
-    up = ['k','w'] #straight
-    left = ['h','a'] #straight
-    down = ['j','s'] #back
-    right = ['l','d'] #back
-
-    line = left + right
-    column = up + down
-
-    def rev(rl):
-        if m in left + up:
-            gl = game_logic(rl) #k
-        else:
-            gl = game_logic(rl[::-1])[::-1] #j
         return gl
                 
-    if m in line:
+    def movement(self):
-        for i in range(0,board_size,board_line):
+        self.stdscr.addstr(10, 0, '\nMove the numbers: ')
-            rl = board[i:i+board_line]
+        m = self.stdscr.getkey()
-            board[i:i+board_line] = rev(rl)
+        self.moved=False
-    elif m in column:
+        board_temp=copy.deepcopy(self.board)
-        for i in range(board_line):
+        self.move(m)
-            rl = board[i::board_line]
-            board[i::board_line] = rev(rl)
-    elif m in undo:
-        board=board_reset
-    else:
-        raise ValueError('Can not move this way')
 
-    if m not in undo and moved == True:
+        if m not in self.undo and self.moved == True:
-        board_reset=copy.deepcopy(board_temp)
+            self.board_reset = copy.deepcopy(board_temp)
+
+    def move(self, m):
+        if m in self.line:
+            for i in range(0,self.board_size,self.board_line):
+                rl = self.board[i:i+self.board_line]
+                self.board[i:i+self.board_line] = self.reverse(rl,m)
+        elif m in self.column:
+            for i in range(self.board_line):
+                rl = self.board[i::self.board_line]
+                self.board[i::self.board_line] = self.reverse(rl,m)
+        elif m in self.undo:
+            self.board = self.board_reset
+        else:
+            raise ValueError('Can not move this way')
     
     
-def print_board():
+    def print_board(self):
-    for i in range(0,board_size,board_line):
+        for i in range(0,self.board_size,self.board_line):
-        stdscr.addstr(i, 0, '{!s:<4}'.join(' '*(board_line+1)).format(*board[i:i+board_line]))
+            self.stdscr.addstr(i, 0, '{!s:<4}'.join(' '*(self.board_line+1)).format(*self.board[i:i+self.board_line]))
-    stdscr.refresh()
+        self.stdscr.refresh()
     
-def add_number():
+    def add_number(self):
-    try:
-        global board
-        global li
         indices = []
-        indices = [i for i, x in enumerate(board) if x == None]
+        indices = [i for i, x in enumerate(self.board) if x == None]
-        li=len(indices)
+        self.li=len(indices)
         p = random.choice(indices)
-        board[p] = random.choices([2,4],weights=[80,20])[0]
+        self.board[p] = random.choices([2,4],weights=[80,20])[0]
-        stdscr.addstr(13, 0, '\nNew number at position '+str(p+1))
+        self.stdscr.addstr(13, 0, '\nNew number at position '+str(p+1))
-        stdscr.addstr(15,0,str(li)+str(p)+str(indices)+'                 ')
+        self.stdscr.addstr(15, 0,str(self.li)+str(p)+str(indices)+'                 ')
-    except e:
-        print(e)
 
-def run(*args):
+    def run(self, *args):
-    #TODO: Make a class so i can remove globals and simplify code
+        self.game_state = True
-    # class Game():
+        self.add_number()
-    #   def init():
+        self.board_reset = copy.deepcopy(self.board)
-    global li
-    global board
-    global board_reset
-    game_state = True
-    board = []
-    global board_size
-    global board_line
-    board_line = 2
-    board_size = board_line**2
-    for i in range(board_size):
-        board.insert(i,None)
 
-    global stdscr
+        while self.game_state:
-    stdscr = curses.initscr()
-    add_number()
-    board_reset = copy.deepcopy(board)
     
-    global moved
+            self.print_board()
-    while game_state:
+            #self.check_playable()
     
-        print_board()
+            try:
+                self.movement()
+            except ValueError:
+                 #continue
+                 pass
     
-        try:
-            movement()
-        except ValueError:
-            # continue
-            pass
 
-        if moved == False and li == 0:
+            self.stdscr.addstr(13, 0, 'MOVED          ')
-            #game_state = False
+            if self.moved == False:
-            stdscr.addstr(15, 0, 'Game Over')
+                self.stdscr.addstr(13, 0, 'DID NOT MOVE')
-            #print('Game Over')
+                #TODO: Fix continue breaks game over but fixes undo
-            #curses.endwin()
+                continue
-            return
-        stdscr.addstr(13, 0, 'MOVED          ')
     
-        if moved == False:
+            try:
-            stdscr.addstr(13, 0, 'DID NOT MOVE')
+                self.add_number()
-            continue
+            except IndexError:
+                # catch game over here
+                self.game_state = False
+                self.stdscr.addstr(15, 0, 'Game Over')
+                #print('Game Over')
     
-        try:
+    def check_playable(self):
-            add_number()
+        l=0
-        except IndexError:
+        for i in ['h','j','k','l']:
-            # catch game over here
+            if self.li == 1 and self.moved == False:
-            game_state = False
+                self.move(i)
-            print('Game Over')
+                l=l+1
+                self.game_state = False
+                #print('Game Over')
+                #curses.endwin()
+                #self.print_board()
 
-curses.wrapper(run)
+        if l==4:
+            self.stdscr.addstr(15, 0, 'Game Over')
+
+    def close(self):
+        state = True
+        while state:
+            self.stdscr.addstr(16, 0, 'Press q to exit: ')
+            m = self.stdscr.getkey()
+            if m == 'q':
+                state = False
+                curses.endwin()
+
+game = G2048()
+curses.wrapper(game.run)
+game.close()
 
-state = True
-while state:
-    m = stdscr.getkey()
-    if m == 'q':
-        state = False
-        curses.endwin()