first commit

Author: SambhavS

.gitignore

@@ -0,0 +1,92 @@
+.DS_Store
+readme_assets
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*,cover
+.hypothesis/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# IPython Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# dotenv
+.env
+
+# virtualenv
+venv/
+ENV/
+
+# Spyder project settings
+.spyderproject
+
+# Rope project settings
+.ropeproject

Procfile

@@ -0,0 +1 @@
+web: gunicorn app:app --log-file=-

README.md

@@ -0,0 +1,35 @@
+# Squill
+
+Squill is a game where you write a program to control troops and battle your friend! 
+
+Status: Works locally and looks less ugly than it did before but still lots of work to do before actually playable....
+
+## Docs
+
+You will code a JavaScript strategy file with one function called 'turn'. It will have the following signature: 
+
+**turn(color, matrix, strength, x, y)**
+
+
+Your function should return **heal()**, **attack(DIRECTION, NUMBER_OF_TROOPS)**, or **move(DIRECTION, NUMBER_OF_TROOPS)**
+
+
+DIRECTION must be "U" "D" "L" or "R", for up/down/left/right.
+NUMBER_OF_TROOPS should be an integer, indicating the number of troops you would like to move. You cannot move all your troops. It costs one troop to attack and you must have at least one troop protecting your territory. Therefore, you must have at least three troops to attack succesfully.
+
+
+Below is the template of a strategy file.
+
+**function turn(color, matrix, strength, x, y){ < YOUR CODE HERE >}**
+
+Here is a very simple example of a valid file.
+
+**function turn(color, matrix, strength, x, y){ return heal(); }**
+
+All that should be in your file should be your function definition (and comments if desired).
+
+
+Save your JS file and upload it when needed. When both you and your opponent have uploaded your files, you can hit 'Battle!' which will show you your results.
+
+## An Important Note
+**There are also some more rules, but I haven't gotten around to writing them.**

app.py

@@ -0,0 +1,61 @@
+from flask import Flask, request, render_template
+import random
+import json
+from gamelogic import core_game
+app = Flask(__name__)
+
+# Super Global
+index_to_col = {0: "red", 1: "blue"}
+file_states = dict()
+user_col_states = dict()
+full_game_state = dict()
+reset_state = dict()
+
+@app.route("/reset/<num>")
+def reset(num):
+    del file_states[num]
+    del user_col_states[num]
+    del full_game_state[num]
+    return "reset button clicked"
+
+@app.route("/online/<num>")
+def online(num):
+    return render_template("test.html")
+
+@app.route("/docs/<num>")
+def docs(num):
+    return render_template("docs.html")
+
+@app.route("/upload/<num>", methods=['POST'])
+def upload(num):   
+    if num not in file_states:
+        file_states[num] = dict()
+    if num not in user_col_states:
+        user_col_states[num] = []
+    username, code_text = request.form["username"], request.form["code_text"]
+    if username not in file_states[num] and len(file_states[num]) == 2:
+        return "Too many users: code was not submitted"
+    file_states[num][username] = code_text
+    if username not in [uname for color, uname in user_col_states[num]]:
+        color = index_to_col[len(file_states[num]) - 1]
+        user_col_states[num].append((color, username))
+    return json.dumps(user_col_states[num])
+
+@app.route("/info/<num>")
+def info(num):
+    if num in user_col_states:
+        return json.dumps(user_col_states[num])
+    return json.dumps([])
+
+@app.route("/init/<num>")
+def game(num):  
+    if num not in full_game_state:
+        full_game_state[num] = []
+    red_code = list(file_states[num].items())[0][1]
+    blue_code = list(file_states[num].items())[1][1]
+    boards = core_game(red_code, blue_code, full_game_state[num])
+    return json.dumps(boards)
+
+if __name__ == '__main__':
+    app.run(debug=True, use_reloader=True)
+

gamelogic.py

@@ -0,0 +1,154 @@
+def core_game(red_code, blue_code, state=None):    
+	# Imports & Init
+	import random
+	import json
+	#from pygame import draw, display, Rect, event, QUIT, Color, time, Surface, font
+	from node_vm2 import VM
+	#pygame.init()
+	#pygame.font.init()
+
+	# URL Specific Setup
+	turn_code = dict()
+	turn_code["red"]= red_code 
+	turn_code["blue"] = blue_code 
+
+	# Globals
+	#FONT = font.SysFont("Arial", 24)
+	SQUARE_WID = 75
+	BOARD_WID = 10
+	#WHITE = Color(255, 255, 255)
+	#BLACK = Color(0, 0, 0)
+	#RED = Color(200, 0, 0)
+	#BLUE = Color(0, 0, 200)
+	player_dict = dict()
+	#col_dict = {"blue": BLUE, "red": RED, "white": WHITE}
+	dir_to_delta = { "U":(0, -1), "D":(0, 1), "L":(-1,0), "R": (1,0)}
+	preload_code = open("preload.js").read()
+
+	# Utils
+	def valid_sq(x, y):
+		return x > -1 and x < BOARD_WID and y > -1 and y < BOARD_WID
+
+	def copy_2D(mat):
+		return [[i for i in row] for row in mat]
+
+	def copy_3D(mat):
+		return[copy_2D(i) for i in mat]
+
+	def r_ind():
+		return random.randint(0,BOARD_WID-1)
+
+
+	# Player Class
+	class Player:
+		def __init__(self, color):
+			self.color = color
+			player_dict[color] = self
+
+		def turn(self, mat, strength, x, y):
+			ref = {"mat":copy_2D(mat), "x":x, "y":y}
+			try:
+				with VM() as vm:
+					turn_call = "turn({}, {}, {}, {}, {})".format(" '{}' ".format(self.color), json.dumps(mat), strength, x, y)
+					call_str = "{} {} {}".format(preload_code, turn_code[self.color], turn_call)
+					action = vm.run(call_str)
+					if type(action) == list:
+						return tuple(action)
+			except:
+				print("Error: {}".format(self.color))
+
+	# Core Functions
+	def execute(move, mat, x, y, col):
+		move_id = move[0]
+		move_info = move[1:]
+
+		if move_id == "move":
+			direction = move_info[0]
+			dx, dy = dir_to_delta[direction]
+			num = int(move_info[1])
+			if valid_sq(x+dx, y+dy):
+				sq, to_sq = mat[x][y], mat[x+dx][y+dy]
+				to_col = to_sq[0]
+				units = min(sq[1], num)
+				if to_col in (col, "white"):
+					sq[1] -= units
+					to_sq[0] = col
+					to_sq[1] += units
+
+		elif move_id == "attack":
+			direction = move_info[0]
+			dx, dy = dir_to_delta[direction]
+			num = int(move_info[1])
+			if valid_sq(x+dx, y+dy):
+				sq, to_sq = mat[x][y], mat[x+dx][y+dy]
+				to_col = to_sq[0]
+				units = min(sq[1], num)
+				if to_col not in (col, "white"):
+					if sq[1] - units < 2:
+						return
+					enemy_units = to_sq[1]
+					del_units = units - enemy_units
+					sq[1] -= units + 1
+					if del_units == 0:
+						to_sq[0], to_sq[1] = "white", 0
+					elif del_units > 0:
+						to_sq[0], to_sq[1] = col, del_units
+					else:
+						to_sq[1] -= units
+
+		elif move_id == "heal":
+			mat[x][y][1] += 1
+
+	def setup():
+		Player("blue")
+		Player("red")
+		col_mat = [[["white", 0] for i in range(BOARD_WID)] for j in range(BOARD_WID)]
+		col_mat[r_ind()][r_ind()] = ["blue", 299]
+		col_mat[r_ind()][r_ind()] = ["red", 299]
+		return  col_mat
+
+	def main():
+		col_mat = setup()
+		#screen = display.set_mode((750, 750))
+		#clock = pygame.time.Clock()
+		counter = 0
+		while counter < 10:
+			#for ev in event.get():
+			#	if ev.type == QUIT:
+			#		break
+			#screen.fill((0, 0, 0))
+			next_mat = copy_2D(col_mat)
+			for i, row in enumerate(col_mat):
+				for j, tup in enumerate(row):
+					if "white" not in tup:
+						col, strength = tup
+						move = player_dict[col].turn(copy_2D(next_mat), strength, i, j)
+						if move:
+							execute(move, next_mat, i, j, col)
+
+			col_mat = next_mat
+			if state != None:
+				state.append(copy_3D(col_mat))
+			counter += 1
+			print(counter)
+			#clock.tick(500)
+
+	main()
+	print("finished")
+	return state
+
+
+def local_test():
+	red_code = open("turn_red.js", "r").read()
+	blue_code = open("turn_red.js", "r").read()
+	core_game(red_code, blue_code)
+
+#local_test()
+
+
+
+
+
+
+
+

preload.js

@@ -0,0 +1,17 @@
+//Utils
+function max(n1, n2){
+	if(n1>n2){
+		return n1;
+	}
+	return n2;
+}
+//Moves
+function move(dir, num) {
+	return["move", dir, max(0, num)]
+}
+function heal(){
+	return ["heal"];
+}
+function attack(dir, num){
+	return ["attack", dir, max(0, num)]
+}

requirements.txt

@@ -0,0 +1,2 @@
+Flask
+gunicorn

runtime.txt

@@ -0,0 +1 @@
+python-3.5.1