maze-src: server.rb comparison

comparison server.rb @ 0:1eef88068f9f tip

initial commit of maze game source

author	ferencd
date	Sun, 15 Sep 2019 11:46:47 +0200
parents
children

comparison

equal deleted inserted replaced

--1:000000000000
+:1eef88068f9f
+require 'net/http/server'
+require 'pp'
+require 'ellers'
+require 'wilsons'
+require 'distance_grid'
+require 'pg'
+require 'base62-rb'
+require 'zlib'
+require 'wlang'
+require 'set'
+require 'descends'
+require 'pg'
+require 'database'
+require 'openssl'
+require 'game'
+require 'gs_logger'
+require 'gamedata'
+#
+# Starting the App, updating things that need to be
+#
+$LOG.info 'gameserver 0.1 starting'
+Database.initialize
+#
+# Constants
+#
+CONTENT_TYPE = 'Content-Type'
+MAIN_HTML = 'lab.html'
+CONTENT_TYPES =
+{
+:png => 'image/png',
+:gif => 'image/gif',
+:js  => 'application/javascript'
+}
+GAME_TYPE_MAZE = 1
+GAME_TYPE_ADVENTURE = 2
+GAME_TYPE_STORY = 3
+#################################################################################################################
+# Helper classes
+#################################################################################################################
+#
+# Used to get some extra numbers
+#
+class Integer
+N_BYTES = [42].pack('i').size
+N_BITS = N_BYTES * 16
+MAX = 2 ** (N_BITS - 2) - 1
+MIN = -MAX - 1
+end
+#
+# An extension to the plain string class to provide b62 validations
+#
+class String
+def valid_b62?
+!!match(/^[[:alnum:]]+$/)
+end
+def is_i?
+/\A[-+]?\d+\z/ === self
+end
+def encrypt(key)
+cipher = OpenSSL::Cipher::Cipher.new('DES-EDE3-CBC').encrypt
+cipher.key = Digest::SHA1.hexdigest key
+s = cipher.update(self) + cipher.final
+s.unpack('H*')[0].upcase
+end
+def decrypt(key)
+cipher = OpenSSL::Cipher::Cipher.new('DES-EDE3-CBC').decrypt
+cipher.key = Digest::SHA1.hexdigest key
+s = [self].pack('H*').unpack('C*').pack('c*')
+cipher.update(s) + cipher.final
+end
+end
+#
+# Simple class to NOT to escape HTML code in the wlang renderer
+#
+class SimpleHtmlRenderer < WLang::Dialect
+def highlight(buf, fn)
+var_name  = render(fn)
+var_value = evaluate(var_name)
+buf << var_value
+end
+tag '$', :highlight
+end
+#################################################################################################################
+#                                           Helper methods                                                      #
+#################################################################################################################
+#
+# Provides a fully completed template for the template engine
+#
+def complete_templates(templates)
+(1..5).each do | v |
+templates["gotext#{v}".to_sym] = '' unless templates.has_key? "gotext#{v}".to_sym
+end
+templates
+end
+#
+# Just returns page not found
+#
+def page_not_found
+content_type = {CONTENT_TYPE => 'text/html'}
+retv = [ '<html><center><strong>404 :-(</strong></center></html>' ]
+code = 404
+return code, content_type, retv
+end
+def internal_server_error
+content_type = {CONTENT_TYPE => 'text/html'}
+retv = [ '<html><center><strong>500 :-(</strong></center></html>' ]
+code = 500
+return code, content_type, retv
+end
+#
+# Will create a random room in the grid
+#
+def create_room(grid)
+tries = 0
+can_not_make = false
+begin
+max_width = [grid.columns/10, 6].max
+max_height = [grid.rows/10, 6].max
+grid_width = rand(2 .. max_width) + 2
+grid_height = rand(2 .. max_height) + 2
+x1 = rand(grid.columns - grid_width - 4)
+x2 = x1 + grid_width
+y1 = rand(grid.rows - grid_height - 4)
+y2 = y1 + grid_height
+tries += 1
+can_not_make = !grid.can_make_room(x1,y1,x2,y2)
+end while can_not_make && tries > 5
+return '' if tries >= 5
+grid.create_room x1, y1, x2, y2
+# Place the door
+door_x_cell  = x1 + grid_width / 2
+door_y_top_cell = y1
+door_y_bottom_cell = y1 + 1
+"{r:#{door_y_bottom_cell},c:#{door_x_cell},v:0}, {r:#{door_y_top_cell},c:#{door_x_cell},v:1}"
+end
+#
+# Calculates the distance from the goal cell on the given grid towards the cell_to_go
+# and returns the final_len and final_path
+#
+def distance_calculator(goal, grid, cell_to_go, final_len, final_path)
+another_distances = goal.distances
+grid.distances = another_distances.path_to(cell_to_go)
+jsv2 = grid.distances_js_array_path
+final_len += jsv2.length
+final_path += jsv2
+return final_len, final_path
+end
+#
+# Generates a path for the given walker
+#
+def create_walker_path(grid, r, c)
+# making a new path from the furthest point from there
+new_distances = grid[r, c].distances
+# goal will be the cell which is the furthest from the new_start and max_dist the length of it
+goal, _ = new_distances.max
+grid.distances = new_distances.path_to(goal)
+jsv = grid.distances_js_array_path
+final_path = jsv
+final_len = final_path.length
+# And the goal is that the walker will take a round around the maze
+# Now add in another path to (0,0)
+final_len, final_path = distance_calculator(goal, grid, grid[0, 0],final_len, final_path)
+final_len, final_path = distance_calculator(grid[0, 0], grid, grid[0, grid.columns - 1],final_len, final_path)
+final_len, final_path = distance_calculator(grid[0, grid.columns - 1], grid, grid[grid.rows - 1, grid.columns - 1],final_len, final_path)
+s = ''
+s << "path_len:#{final_len},r:#{r},c:#{c},p:'#{final_path}'"
+s
+end
+# will generate a few walking characters
+def generate_walkers(grid, max_nr)
+walkers = []
+return walkers if max_nr == 0
+walker_count = rand(1 .. max_nr + 1)
+$LOG.info"Generating #{walker_count} walkers\n"
+#walkers << {:body => 0, :row => 0, :col => 1, :path => "path_len:3,r:0,c:1,p:'EEE'"}
+#walkers << {:body => 0, :row => 0, :col => 4, :path => "path_len:3,r:0,c:4,p:'WWW'"}
+dbg_cwa = 0
+(1..walker_count).each do
+walker_body = dbg_cwa #rand(3)
+dbg_cwa = 1 if dbg_cwa == 0
+walker_row = rand(1 .. grid.rows - 2) + 1
+walker_col = rand(1 .. grid.columns - 2) + 1
+walkers <<
+{
+:body => walker_body,
+:row => walker_row,
+:col => walker_col,
+:path => create_walker_path(grid,walker_row,walker_col)
+}
+end
+walkers
+end
+#
+# Will put the loot stuff on the level. food_locations is an array where wealready have placed food
+#
+def place_loot(grid, food_locations)
+loot_js = 'var loot=['
+max_possible_loot = grid.dead_ends[1].length + grid.dead_ends[2].length + grid.dead_ends[4].length + grid.dead_ends[8].length
+max_possible_loot = max_possible_loot / 4 + 1
+max_loot_count = $ITEMS.length       # 32 items defined in the png_to_js
+loot_count = [rand(max_possible_loot), max_loot_count].min # We want a lot of loot in the maze
+current_loot_count = 0
+idxs = [1, 2, 4, 8]
+idxsc = 0
+current_idx = idxs[idxsc]
+loot_js_arr = []
+placed_loots = []
+current_loot_value = 0
+(1..loot_count).each do |_|
+place_ctr = 0
+can_place = true
+begin
+cell = grid.dead_ends[current_idx][rand (grid.dead_ends[current_idx].length)]
+place_ctr += 1
+already_placed_here = placed_loots.select {|loot_loc| loot_loc[:r] == cell.row && loot_loc[:c] == cell.column}
+here_is_not_fine = already_placed_here.length > 0
+unless here_is_not_fine
+food_placed_here = food_locations.select {|food_loc| food_loc[:r] == cell.row && food_loc[:c] == cell.column}
+here_is_not_fine |= food_placed_here.length > 0
+end
+end while here_is_not_fine && place_ctr < grid.dead_ends[current_idx].length-1
+if place_ctr == grid.dead_ends[current_idx].length-1
+if already_placed_here.length > 0
+# try to find the first non empty place in the grid
+found = false
+(0..grid.dead_ends[current_idx].length - 1).each do |i|
+cell = grid.dead_ends[current_idx][i]
+already_placed_here = placed_loots.select {|loot_loc| loot_loc[:r] == cell.row && loot_loc[:c] == cell.column}
+can_go_here = already_placed_here.length == 0
+food_placed_here = food_locations.select {|loot_loc| loot_loc[:r] == cell.row && loot_loc[:c] == cell.column}
+can_go_here &= food_placed_here.length == 0
+if can_go_here
+found = true
+break
+end
+end
+can_place = false if found
+end
+end
+if can_place
+loot_js_arr << "{r:#{cell.row},c:#{cell.column},t:#{current_loot_count}}" if (cell.row > 0 && cell.column > 0)
+current_loot_value += $ITEMS[current_loot_count][:value]
+placed_loots << {:r => cell.row, :c => cell.column}
+else
+break
+end
+current_idx = idxs[idxsc]
+idxsc += 1
+if idxsc == idxs.length
+idxsc = 0
+end
+current_loot_count += 1
+if current_loot_count == max_loot_count
+current_loot_count = 0
+end
+end
+loot_js << loot_js_arr.join(',') << "];\n"
+return loot_js, placed_loots, current_loot_value
+end
+#
+# Will put the food on the table ... ie. level
+#
+def place_food(grid, level_number, game_type)
+food_js = 'var food=['
+max_possible_food = grid.dead_ends[1].length + grid.dead_ends[2].length + grid.dead_ends[4].length + grid.dead_ends[8].length
+max_possible_food = max_possible_food / 4 + 1
+food_count = rand(max_possible_food)
+if game_type == GAME_TYPE_STORY
+if level_number > 55
+food_count *= 4
+elsif level_number > 45
+food_count *= 3
+elsif level_number > 20
+food_count *= 2
+elsif level_number < 10
+food_count /= 2
+food_count += 1
+end
+end
+max_food_count = 10       # This comes from png_to_js the number of possible food items available
+current_food_count = 0    # Counts the food items of the max available
+idxs = [1, 2, 4, 8]       # The indexes of the cells, which are "dead ends".
+idxsc = 0                 # Counter for the "dead end" index array
+current_idx = idxs[idxsc] # The current "dead end" index
+food_js_arr = []          # Will hold the javascript array for the food stuff
+placed_foods = []         # Will hold where the food was placed
+(1..food_count).each do |_|
+place_ctr = 0
+can_place = true
+# Find a place (cell) where we can place the food item
+begin
+cell = grid.dead_ends[current_idx][rand (grid.dead_ends[current_idx].length)]
+place_ctr += 1
+already_placed_here = placed_foods.select {|food_loc| food_loc[:r] == cell.row && food_loc[:c] == cell.column}
+end while already_placed_here.length>0 && place_ctr < grid.dead_ends[current_idx].length-1
+if place_ctr == grid.dead_ends[current_idx].length-1
+# Did not find an "empty dead end" cell to put the food there
+if already_placed_here.length > 0
+# try to find the first empty cell in the grid
+found = false
+(0..grid.dead_ends[current_idx].length - 1).each do |i|
+cell = grid.dead_ends[current_idx][i]
+already_placed_here = placed_foods.select {|food_loc| food_loc[:r] == cell.row && food_loc[:c] == cell.column}
+if already_placed_here.length == 0
+found = true
+break
+end
+end
+can_place = false if found
+end
+end
+if can_place
+food_js_arr << "{r:#{cell.row},c:#{cell.column},t:#{current_food_count}}" if (cell.row > 0 && cell.column > 0)
+placed_foods << {:r => cell.row, :c => cell.column}
+else
+break
+end
+current_idx = idxs[idxsc]
+idxsc += 1
+if idxsc == idxs.length
+idxsc = 0
+end
+current_food_count += 1
+if current_food_count == max_food_count
+current_food_count = 0
+end
+end
+food_js << food_js_arr.join(',') << "];\n"
+return food_js, placed_foods
+end
+def place_torches(grid)
+torches = grid.identify_torch_locations
+torch_data = []
+torches.each do |torch|
+torch_data << "{i:#{torch[:i]},j:#{torch[:j]},p:#{torch[:number]}}"
+end
+torch_str = "var torch_placements=[#{torch_data.join(',')}];\n"
+storch_str = Utils.split(torch_str, 80)
+storch_str
+end
+def place_doors(grid, exit_row, exit_col)
+doors_js = []
+# Create a few rooms in the grid
+room_count = 0 #rand(4 .. 10)
+(1..room_count).each do
+room_js = create_room(grid)
+if room_js
+doors_js << room_js
+else
+break
+end
+end
+# 0 -> cell with a top door, 1 -> cell with a bottom door in
+# adding a door at (0,0) just for visual effects :)
+# add another door at (width, height) to indicate exit
+doors_js << '{r:0,c:0,v:0}'
+doors_js << "{r:#{exit_row},c:#{exit_col},v:5}"
+doors_str = "var doors=[ #{doors_js.join(',')}];\nvar exit_row=#{exit_row};\nvar exit_col=#{exit_col};";
+sdoors_str = Utils.split(doors_str, 80)
+sdoors_str
+end
+def place_weapons(food_locations, grid, height, width)
+weapons_js = 'var weapon_locations = ['
+weapon_locs = []
+all_weapons = [0, 1, 2, 3] # 0 - spear, armor, shoe, ring
+special_weapons = [2, 3].to_set
+shoe_distance = 0
+ring_distance = 0
+all_weapons.each do |weapon|
+distance_len = 101
+begin
+wcol = 1 + rand(width - 2)
+wrow = 1+ rand(height - 2)
+fl = 0
+fp = ''
+wep_cell = grid[wrow, wcol]
+cell00 = grid[0, 0]
+distance_len, _ = distance_calculator(wep_cell, grid, cell00, fl, fp)
+if weapon == 2
+shoe_distance = distance_len
+end
+if weapon == 3
+ring_distance = distance_len
+end
+foods_already_placed_here = food_locations.select {|food_loc| food_loc[:r] == wrow && food_loc[:c] == wcol}
+food_here = foods_already_placed_here.length > 0
+weapons_placed_here = weapon_locs.select {|weapon_loc| weapon_loc[:r] == wrow && weapon_loc[:c] == wcol}
+weapon_here = weapons_placed_here.length > 0
+end while (distance_len > 101 && special_weapons.include?(weapon)) || food_here || weapon_here
+weapon_locs << {:r => wrow, :c => wcol, :t => weapon}
+end
+weap_tmp_arr=[]
+weapon_locs.each {|wpl| weap_tmp_arr << "{r:#{wpl[:r]},c:#{wpl[:c]},t:#{wpl[:t]}}"}
+weapons_js << weap_tmp_arr.join(',') << "];\n"
+return weapons_js, shoe_distance, ring_distance
+end
+#
+# Will create a new maze with the given number as the seed for the random generator.
+#
+def handle_maze_with_number(level_number, game_id, main_html='lab.html', game_type = GAME_TYPE_STORY)
+current_seed = 0x2ECD06801D ^ level_number
+# Set the seed based on the level number
+srand(current_seed)
+minwidth = 10
+minheight = 10
+maxwidth = 30
+maxheight = 30
+# There are no walkers, so the system should be able to handle it
+if game_type == GAME_TYPE_MAZE
+maxwidth = 40
+maxheight = 40
+end
+maxwidth = [minwidth + level_number, maxwidth].min
+maxheight = [minheight + level_number, maxheight].min
+width =  rand(minwidth .. maxwidth)
+height = rand(minheight ..maxheight)
+$LOG.info "GameID:#{game_id} Generated: #{width} x #{height} for level  #{level_number}"
+grid = DistanceGrid.new(height, width)
+wilson = Wilsons.new
+wilson.on grid
+maze_js = ''
+maze_js << "history.pushState(null, null, '/#{game_id}');"
+maze_js << "var w = #{width};\n"
+maze_js << "var h = #{height};\n"
+maze_js << "#{grid.maze_js_array}\n"
+# Now identify all the places where a torch can go
+storch_str = place_torches(grid)
+maze_js << storch_str
+# Where the exit is for now
+exit_col = width - 1
+exit_row = height- 1
+# At a later stage the exit will not be exactly at the end of the maze, but at the furthest cell from (0,0)
+# start = grid[0,0]
+# distances = start.distances
+# new_start, _ = distances.max
+#if game_type == GAME_TYPE_ADVENTURE
+#  exit_col = new_start.column
+#  exit_row = new_start.row
+#end
+# Calculate the shortest path from the entrance to the exit
+fp_fl = 0
+fp_fp = ''
+fp_wep_cell = grid[exit_row, exit_col]
+fp_cell00 = grid[0,0]
+full_path_len, _ = distance_calculator(fp_wep_cell, grid, fp_cell00, fp_fl, fp_fp)
+$LOG.info "Distance from (0,0) to (#{exit_col}, #{exit_row}) is #{full_path_len} steps"
+loot_value = 0
+walkers = []
+food_locations = []
+# Create a few rooms with doors. Notes:
+# 1. This is not done due to various reasons yet
+sdoors_str = place_doors(grid, exit_row, exit_col)
+maze_js << sdoors_str
+# Create a few walkers but only if the game type is not a simple maze runner
+if game_type != GAME_TYPE_MAZE
+max_walkers = 0
+if game_type == GAME_TYPE_STORY
+max_walkers = [ [1, level_number - 3].max, 15].min if level_number > 4
+else
+max_walkers = rand(3..15)
+end
+walkers = generate_walkers(grid, max_walkers)
+walkers_str_array = []
+walkers.each do |walker|
+walkers_str_array << "{t:#{walker[:body]},#{walker[:path]}}"
+end
+walkers_js = "var walkers=[#{walkers_str_array.join(',')}];\n"
+maze_js << Utils.split(walkers_js, 80)
+maze_js << "var walkers_count = #{walkers.length};"
+else
+maze_js << "var walkers=[];\nvar walkers_count=0;"
+end
+# Food items
+if game_type != GAME_TYPE_MAZE
+food_js, food_locations = place_food(grid, level_number, game_type)
+maze_js << "#{food_js}"
+else
+maze_js << "var food=[];\n"
+end
+# Loot in the maze only if this is an adventure game
+if game_type == GAME_TYPE_ADVENTURE
+loot_js, loot_locations, loot_value = place_loot(grid, food_locations)
+# Just hack the food locations to contain all the loot
+(food_locations << loot_locations).flatten!
+else
+loot_js = "var loot=[];\n"
+end
+maze_js << "#{loot_js}"
+shoe_distance = 0
+ring_distance = 0
+# Weapons
+if game_type != GAME_TYPE_MAZE
+weapons_js,shoe_distance,ring_distance = place_weapons(food_locations, grid, height, width)
+maze_js << "#{weapons_js}"
+else
+maze_js << "var weapon_locations=[];\n"
+end
+templated_maze = IO.binread(main_html)
+if $arrives.has_key? level_number
+templates_arrives = $arrives[level_number]
+else
+templates_arrives = $generic_arrives
+end
+complete_templates templates_arrives
+templates_arrives[:gid] = "#{game_id}"
+templates_arrives[:lid] = "#{level_number}"
+templates_arrives[:page_loader] = 'upon_page_load();'
+# templates_arrives[:page_loader] = 'setup_labyrinth();' if game_type == GAME_TYPE_ADVENTURE or game_type == GAME_TYPE_MAZE
+templates_arrives[:sysmenu_visible] = 'hidden;'
+templates_arrives[:sysmenu_display] = 'none;'
+templates_arrives[:menu_line_visible] = 'visible;'
+level_statistics = "Level Number:#{level_number}\nExit at (#{exit_col}, #{exit_row}).\nDistance from (0,0) to (#{exit_col}, #{exit_row}) is #{full_path_len}"
+templates_arrives[:badbrowser_visible] = 'hidden;'
+templates_arrives[:badbrowser_display] = 'none;'
+templates_arrives[:health_visible] = 'visible'
+templates_arrives[:statis_visible] = 'hidden'
+templates_arrives[:gameid_size] = '105px'
+templates_arrives[:gameid_visible] = 'visible'
+templates_arrives[:equipment_visible] = 'hidden'
+templates_arrives[:messages_visible] = 'hidden; display:none'
+if game_type == GAME_TYPE_ADVENTURE
+templates_arrives[:gold_visible] = 'visible'
+templates_arrives[:skeletons_visible] = 'visible'
+templates_arrives[:levelctr_visible] = 'hidden; display:none'
+templates_arrives[:timer_visible] = 'visible'
+templates_arrives[:day_or_level] = 'Level'
+templates_arrives[:new_game_type] = 'new_adventure_game'
+level_statistics << "\nGold to be found in this dungeon: #{loot_value}\nSkeletons: #{walkers.length}\nSkeletons' acumen: Droidlike\n"
+level_statistics << "Boots of Lightness at #{shoe_distance} steps apart from the start\nRing of Health #{ring_distance} steps apart from the start"
+else
+templates_arrives[:gold_visible] = 'hidden; display:none'
+templates_arrives[:skeletons_visible] = 'hidden; display:none'
+templates_arrives[:levelctr_visible] = 'visible'
+templates_arrives[:timer_visible] = 'hidden; display:none'
+templates_arrives[:new_game_type] = 'new_story_game'
+templates_arrives[:day_or_level] = 'Day'
+if game_type == GAME_TYPE_MAZE
+templates_arrives[:levelctr_visible] = 'hidden; display:none'
+templates_arrives[:health_visible] = 'hidden; display:none'
+templates_arrives[:equipment_visible] = 'hidden; display:none'
+templates_arrives[:timer_visible] = 'visible'
+templates_arrives[:statis_visible] = 'visible'
+templates_arrives[:new_game_type] = 'new_timechaser_game'
+else
+templates_arrives[:messages_visible] = 'visible'
+end
+end
+templates_arrives[:story_game_loc] = Game.gen_game_url 'SG'
+templates_arrives[:adv_game_loc] = Game.gen_game_url 'AG'
+templates_arrives[:timer_game_loc] = Game.gen_game_url 'TG'
+templates_arrives[:level_statistics] = level_statistics
+full_maze = SimpleHtmlRenderer.render(templated_maze, templates_arrives)
+full_maze << '<script type="text/javascript">'
+gt = case game_type
+when GAME_TYPE_ADVENTURE then 'GAME_TYPE_ADVENTURE'
+when GAME_TYPE_STORY then 'GAME_TYPE_STORY'
+when GAME_TYPE_MAZE then 'GAME_TYPE_TIMERUN'
+else 'GAME_TYPE_TIMERUN'
+end
+javascripts = ''
+javascripts << "const GAME_TYPE_ADVENTURE = 1;\nconst GAME_TYPE_STORY = 2;\nconst GAME_TYPE_TIMERUN = 3\n;var game_type=#{gt};\n"
+javascripts << maze_js
+if game_type == GAME_TYPE_ADVENTURE
+templates_descends = $adventure_descend_summary
+else
+if game_type == GAME_TYPE_STORY
+if $descends.has_key? level_number
+templates_descends =  $descends[level_number]
+else
+templates_descends = $generic_descends
+end
+else
+templates_descends = $timerun_descends
+end
+end
+javascripts << "var story_text =\"#{templates_descends[:story_text]}\";\n"
+javascripts << "var leave_text =\"#{templates_descends[:leave_text]}\";\n"
+javascripts << '</script>'
+#  javascripts << '<script type="text/javascript" src="graphics.js"></script>'
+#
+#  javascripts << '<script type="text/javascript" src="game.js"></script>'
+#  templated_game_js = IO.binread 'game.js'
+#  game_js = SimpleHtmlRenderer.render(templated_game_js, templates_descends)
+#  javascripts << game_js
+full_maze << javascripts
+full_maze << 'request("graphics.js");</script></body></html>'
+retv = [full_maze]
+return 200, retv
+end
+#
+# Handles the root request. Creates a new maze number
+#
+def handle_root
+templated_maze = IO.binread(MAIN_HTML)
+templates_arrives = $generic_arrives
+complete_templates templates_arrives
+templates_arrives[:gid] = ''
+templates_arrives[:lid] = ''
+templates_arrives[:page_loader] = 'page_loader();'
+templates_arrives[:sysmenu_visible] = 'visible;'
+templates_arrives[:sysmenu_display] = 'block;'
+templates_arrives[:menu_line_visible] = 'hidden;'
+templates_arrives[:gameid_visible] = 'hidden'
+templates_arrives[:gold_visible] = 'hidden'
+templates_arrives[:skeletons_visible] = 'hidden'
+templates_arrives[:levelctr_visible] = 'hidden'
+templates_arrives[:health_visible] = 'hidden'
+templates_arrives[:timer_visible] = 'hidden'
+templates_arrives[:gameid_size] = '0px; padding:0'
+templates_arrives[:day_or_level] = 'Stage'
+templates_arrives[:level_statistics] = 'Nothing here yet'
+templates_arrives[:statis_visible] = 'hidden'
+templates_arrives[:equipment_visible] = 'hidden'
+templates_arrives[:new_game_type] = 'page_loader'
+templates_arrives[:messages_visible] = 'hidden'
+templates_arrives[:badbrowser_visible] = 'hidden;'
+templates_arrives[:badbrowser_display] = 'none;'
+templates_arrives[:story_game_loc] = Game.gen_game_url 'SG'
+templates_arrives[:adv_game_loc] = Game.gen_game_url 'AG'
+templates_arrives[:timer_game_loc] = Game.gen_game_url 'TG'
+full_maze = SimpleHtmlRenderer.render(templated_maze, templates_arrives)
+full_maze << '</body></html>'
+retv = [full_maze]
+return 200, retv
+end
+#
+# Delivers a file to the browser
+#
+def deliver_file(name)
+code, content_type, retv = page_not_found
+# Will read a file. Supposed to be on the same level as the script
+filename = name[1..-1]
+if File.exists?(filename)
+extension = filename.partition('.').last
+code = 200
+content_type = { CONTENT_TYPE => CONTENT_TYPES[extension] }
+retv = [ IO.binread(name.partition('/').last) ]
+end
+return code, content_type, retv
+end
+def handle_game_loader(loc)
+begin
+key = loc[0..5]
+enced = loc[6..-1]
+deced = enced.decrypt key
+rescue
+deced = 'SG'
+end
+game_type = case deced
+when 'SG' then
+deced
+when 'AG' then
+deced
+when 'TG' then
+deced
+else
+'SG'
+end
+code, retv = Game.create_game game_type
+return code, retv
+end
+def retrieve_game_id(request)
+gid = ''
+gid = request[:headers]['X-Extra'] if request[:headers].has_key? 'X-Extra'
+gid = gid.split('=')[1] if gid && gid.count('=') > 0
+gid
+end
+def handle_next_level(gid)
+# See where the player was
+level_nr = Database.get_db_level_for_gid gid
+# Move him to the next level
+level_nr += 1
+Database.update_level_number_for_gid(level_nr, gid)
+# And let's play that level
+code, retv = handle_maze_with_number(level_nr, gid, MAIN_HTML, GAME_TYPE_STORY)
+return code, retv
+end
+#
+# Each connection will get in here
+#
+Net::HTTP::Server.run(:port => 8180) do |request, _|
+begin
+url = request[:uri]
+code, content_type, retv = page_not_found
+lab_id = url[:path]
+# pp lab_id
+# what we are trying to load
+what = lab_id.to_s
+# Handle favico
+if what == '/favicon.ico'
+code = 200
+content_type = {CONTENT_TYPE => 'image/x-icon'}
+retv = [ IO.binread('favicon.ico') ]
+end
+# Nothing, just load the default, and create a new maze
+if what == '/'
+code, retv = handle_root
+elsif what != '/favicon.ico'
+# some file that needs to be delivered?
+if what.end_with?('.js') or what.end_with?('.png') or what.end_with?('.gif')
+code, content_type, retv = deliver_file(what)
+else
+# The actual location
+loc = what[1..-1]
+# See if this is a gametype loader from the main screen, ie full hex string:
+if loc =~ /^[0-9A-F]+$/i and not loc.is_i?
+code, retv = handle_game_loader(loc)
+else
+# gid will be the Game ID of the current game if story mode, otherwise the adventure mode is selected for the
+# current maze
+gid = retrieve_game_id(request)
+# Crazy locations will lead to random maze games
+if loc.length > 9
+loc = 'T' + Utils.random_string(8)
+end
+if gid == loc
+# The player advanced to the next level from the game, we have a valid gid equaling the location of the window
+code, retv = handle_next_level(gid)
+elsif loc.is_i?
+# We get here by a simple "GET" from the browser URL, someone just wants to play a maze game
+# Now update in the DB the level number for gid
+code, retv = handle_maze_with_number(loc.to_i, gid, MAIN_HTML, GAME_TYPE_MAZE)
+elsif loc.length > 0 and (loc[0] == 'S' or loc[0] == 'A' or loc[0] == 'T')
+level_number = Database.get_db_level_for_gid(loc)
+if level_number == -1
+level_number = Zlib::crc32(loc, 0)
+end
+code, retv = handle_maze_with_number(level_number, loc,
+MAIN_HTML,
+if loc[0] == 'S' then GAME_TYPE_STORY elsif loc[0] == 'T' then GAME_TYPE_MAZE
+else GAME_TYPE_ADVENTURE end
+)
+end
+end
+end
+end
+rescue => ex
+$LOG.fatal("A Somewhat critical error: #{ex.to_s}")
+code, content_type, retv = internal_server_error
+raise
+end
+# This will go back to the caller
+reply = [code, content_type, retv]
+reply
+end

Mercurial > maze-src

comparison server.rb @ 0:1eef88068f9f tip