generator work

git-svn-id: http://svn.net-core.org/repos/t-engine4@389 51575b47-30f0-44d4-a5cc-537603b46e54

game/engine/Generator.lua

 require "engine.class"
 module(..., package.seeall, class.make)
 
-function _M:init(zone, map)
+function _M:init(zone, map, level)
 	self.zone = zone
 	self.map = map
+	self.level = level
+
+	-- Setup the map's room-map
+	if not map.room_map then
+		map.room_map = {}
+		for i = 0, map.w - 1 do
+			map.room_map[i] = {}
+			for j = 0, map.h - 1 do
+				map.room_map[i][j] = {}
+			end
+		end
+	end
 end
 
 function _M:generate()
-
 end

game/engine/Zone.lua

@@ -291,17 +291,22 @@ function _M:newLevel(level_data, lev, old_lev, game)
 	if level_data.all_lited then map:liteAll(0, 0, map.w, map.h) end
 	if level_data.all_remembered then map:rememberAll(0, 0, map.w, map.h) end
 
+	-- Setup the entities list
+	local level = self.level_class.new(lev, map)
+	level:setEntitiesList("actor", self:computeRarities("actor", self.npc_list, level, nil))
+	level:setEntitiesList("object", self:computeRarities("object", self.object_list, level, nil))
+	level:setEntitiesList("trap", self:computeRarities("trap", self.trap_list, level, nil))
+
 	-- Generate the map
 	local generator = require(level_data.generator.map.class).new(
 		self,
 		map,
-		self.grid_list,
+		level,
 		level_data.generator.map
 	)
 	local ux, uy, dx, dy, spots = generator:generate(lev, old_lev)
 	spots = spots or {}
 
-	local level = self.level_class.new(lev, map)
 	level.ups = {{x=ux, y=uy}}
 	level.downs = {{x=dx, y=dy}}
 	level.spots = spots
@@ -312,7 +317,7 @@ function _M:newLevel(level_data, lev, old_lev, game)
 	-- Setup the level in the game
 	game:setLevel(level)
 
-	-- Generate objects (before actors so that actors can use the probability list of objects to get equipments)
+	-- Generate objects
 	if level_data.generator.object then
 		local generator = require(level_data.generator.object.class).new(
 			self,
@@ -345,5 +350,8 @@ function _M:newLevel(level_data, lev, old_lev, game)
 		generator:generate()
 	end
 
+	-- Delete the room_map, now useless
+	map.room_map = nil
+
 	return level
 end

game/engine/generator/actor/Random.lua

@@ -8,11 +8,10 @@ function _M:init(zone, map, level)
 	self.level = level
 	local data = level.data.generator.actor
 
-	-- Setup the entities list
-	level:setEntitiesList("actor", zone:computeRarities("actor", zone.npc_list, level, nil))
-
-	if data.adjust_level and game:getPlayer() then
+	if data.adjust_level then
 		self.adjust_level = {base=zone.base_level, min=data.adjust_level[1], max=data.adjust_level[2]}
+	else
+		self.adjust_level = {base=zone.base_level, lev = self.level.level, min=0, 0}
 	end
 	self.filters = data.filters
 	self.nb_npc = data.nb_npc or {10, 20}

game/engine/generator/map/Empty.lua

@@ -3,8 +3,9 @@ local Map = require "engine.Map"
 require "engine.Generator"
 module(..., package.seeall, class.inherit(engine.Generator))
 
-function _M:init(zone, map, grid_list, data)
-	engine.Generator.init(self, zone, map)
+function _M:init(zone, map, level, data)
+	engine.Generator.init(self, zone, map, level)
+	local grid_list = zone.grid_list
 	self.floor = grid_list[data.floor]
 	self.up = grid_list[data.up]
 end

game/engine/generator/map/Maze.lua

@@ -4,8 +4,9 @@ require "engine.Generator"
 module(..., package.seeall, class.inherit(engine.Generator))
 
 function _M:init(zone, map, grid_list, data)
-	engine.Generator.init(self, zone, map)
+	engine.Generator.init(self, zone, map, level)
 	self.data = data
+	local grid_list = zone.grid_list
 	self.floor = grid_list[data.floor]
 	self.wall = grid_list[data.wall]
 	self.up = grid_list[data.up]

game/engine/generator/map/Roomer.lua

@@ -4,26 +4,18 @@ require "engine.Generator"
 module(..., package.seeall, class.inherit(engine.Generator))
 
 function _M:init(zone, map, grid_list, data)
-	engine.Generator.init(self, zone, map)
+	engine.Generator.init(self, zone, map, level)
 	self.data = data
 	self.data.tunnel_change = self.data.tunnel_change or 30
 	self.data.tunnel_random = self.data.tunnel_random or 10
 	self.data.door_chance = self.data.door_chance or 50
 	self.data.lite_room_chance = self.data.lite_room_chance or 25
-	self.grid_list = grid_list
+	self.grid_list = zone.grid_list
 
 	self.rooms = {}
 	for i, file in ipairs(data.rooms) do
 		table.insert(self.rooms, self:loadRoom(file))
 	end
-
-	self.room_map = {}
-	for i = 0, self.map.w - 1 do
-		self.room_map[i] = {}
-		for j = 0, self.map.h - 1 do
-			self.room_map[i][j] = {}
-		end
-	end
 end
 
 function _M:loadRoom(file)
@@ -84,7 +76,7 @@ function _M:roomAlloc(room, id, lev, old_lev)
 		-- Do we stomp ?
 		for i = 1, room.w do
 			for j = 1, room.h do
-				if self.room_map[i-1+x][j-1+y].room then ok = false break end
+				if self.map.room_map[i-1+x][j-1+y].room then ok = false break end
 			end
 			if not ok then break end
 		end
@@ -98,11 +90,11 @@ function _M:roomAlloc(room, id, lev, old_lev)
 			else
 				for i = 1, room.w do
 					for j = 1, room.h do
-						self.room_map[i-1+x][j-1+y].room = id
+						self.map.room_map[i-1+x][j-1+y].room = id
 						local c = room[i][j]
 						if c == '!' then
-							self.room_map[i-1+x][j-1+y].room = nil
-							self.room_map[i-1+x][j-1+y].can_open = true
+							self.map.room_map[i-1+x][j-1+y].room = nil
+							self.map.room_map[i-1+x][j-1+y].can_open = true
 							self.map(i-1+x, j-1+y, Map.TERRAIN, self.grid_list[self:resolve('#')])
 						else
 							self.map(i-1+x, j-1+y, Map.TERRAIN, self.grid_list[self:resolve(c)])
@@ -150,9 +142,9 @@ function _M:markTunnel(x, y, xdir, ydir, id)
 	local dir = coord_to_dir[xdir][ydir]
 	for i, d in ipairs(mark_dirs[dir]) do
 		local xd, yd = dir_to_coord[d][1], dir_to_coord[d][2]
-		if self.map:isBound(x+xd, y+yd) and not self.room_map[x+xd][y+yd].tunnel then self.room_map[x+xd][y+yd].tunnel = id print("mark tunnel", x+xd, y+yd , id) end
+		if self.map:isBound(x+xd, y+yd) and not self.map.room_map[x+xd][y+yd].tunnel then self.map.room_map[x+xd][y+yd].tunnel = id print("mark tunnel", x+xd, y+yd , id) end
 	end
-	if not self.room_map[x][y].tunnel then self.room_map[x][y].tunnel = id print("mark tunnel", x, y , id) end
+	if not self.map.room_map[x][y].tunnel then self.map.room_map[x][y].tunnel = id print("mark tunnel", x, y , id) end
 end
 
 --- Tunnel from x1,y1 to x2,y2
@@ -183,17 +175,17 @@ function _M:tunnel(x1, y1, x2, y2, id)
 		end
 		print(feat, "try pos", nx, ny, "dir", coord_to_dir[xdir][ydir])
 
-		if self.room_map[nx][ny].special then
+		if self.map.room_map[nx][ny].special then
 			print(feat, "refuse special")
-		elseif self.room_map[nx][ny].room then
+		elseif self.map.room_map[nx][ny].room then
 			tun[#tun+1] = {nx,ny}
 			x1, y1 = nx, ny
 			print(feat, "accept room")
-		elseif self.room_map[nx][ny].can_open ~= nil then
-			if self.room_map[nx][ny].can_open then
+		elseif self.map.room_map[nx][ny].can_open ~= nil then
+			if self.map.room_map[nx][ny].can_open then
 				print(feat, "tunnel crossing can_open", nx,ny)
-				for i = -1, 1 do for j = -1, 1 do if self.map:isBound(nx + i, ny + j) and self.room_map[nx + i][ny + j].can_open then
---					self.room_map[nx + i][ny + j].can_open = false
+				for i = -1, 1 do for j = -1, 1 do if self.map:isBound(nx + i, ny + j) and self.map.room_map[nx + i][ny + j].can_open then
+--					self.map.room_map[nx + i][ny + j].can_open = false
 --					print(feat, "forbiding crossing at ", nx+i,ny+j)
 				end end end
 				tun[#tun+1] = {nx,ny,true}
@@ -202,13 +194,13 @@ function _M:tunnel(x1, y1, x2, y2, id)
 			else
 				print(feat, "reject can_open")
 			end
-		elseif self.room_map[nx][ny].tunnel then
-			if self.room_map[nx][ny].tunnel ~= id or no_move_tries >= 15 then
+		elseif self.map.room_map[nx][ny].tunnel then
+			if self.map.room_map[nx][ny].tunnel ~= id or no_move_tries >= 15 then
 				tun[#tun+1] = {nx,ny}
 				x1, y1 = nx, ny
-				print(feat, "accept tunnel", self.room_map[nx][ny].tunnel, id)
+				print(feat, "accept tunnel", self.map.room_map[nx][ny].tunnel, id)
 			else
-				print(feat, "reject tunnel", self.room_map[nx][ny].tunnel, id)
+				print(feat, "reject tunnel", self.map.room_map[nx][ny].tunnel, id)
 			end
 		else
 			tun[#tun+1] = {nx,ny}
@@ -245,7 +237,7 @@ function _M:makeStairsInside(lev, old_lev, spots)
 	if lev < self.zone.max_level or self.data.force_last_stair then
 		while true do
 			dx, dy = rng.range(1, self.map.w - 1), rng.range(1, self.map.h - 1)
-			if not self.map:checkEntity(dx, dy, Map.TERRAIN, "block_move") and not self.room_map[dx][dy].special then
+			if not self.map:checkEntity(dx, dy, Map.TERRAIN, "block_move") and not self.map.room_map[dx][dy].special then
 				self.map(dx, dy, Map.TERRAIN, self.grid_list[self:resolve("down")])
 				break
 			end
@@ -256,7 +248,7 @@ function _M:makeStairsInside(lev, old_lev, spots)
 	local ux, uy
 	while true do
 		ux, uy = rng.range(1, self.map.w - 1), rng.range(1, self.map.h - 1)
-		if not self.map:checkEntity(ux, uy, Map.TERRAIN, "block_move") and not self.room_map[ux][uy].special then
+		if not self.map:checkEntity(ux, uy, Map.TERRAIN, "block_move") and not self.map.room_map[ux][uy].special then
 			self.map(ux, uy, Map.TERRAIN, self.grid_list[self:resolve("up")])
 			break
 		end
@@ -277,7 +269,7 @@ function _M:makeStairsSides(lev, old_lev, sides, rooms, spots)
 			elseif sides[2] == 2 then dx, dy = rng.range(1, self.map.w - 1), self.map.h - 1
 			end
 
-			if not self.room_map[dx][dy].special then
+			if not self.map.room_map[dx][dy].special then
 				local i = rng.range(1, #rooms)
 				self:tunnel(dx, dy, rooms[i].cx, rooms[i].cy, rooms[i].id)
 				self.map(dx, dy, Map.TERRAIN, self.grid_list[self:resolve("down")])
@@ -295,7 +287,7 @@ function _M:makeStairsSides(lev, old_lev, sides, rooms, spots)
 		elseif sides[1] == 2 then ux, uy = rng.range(1, self.map.w - 1), self.map.h - 1
 		end
 
-		if not self.room_map[ux][uy].special then
+		if not self.map.room_map[ux][uy].special then
 			local i = rng.range(1, #rooms)
 			self:tunnel(ux, uy, rooms[i].cx, rooms[i].cy, rooms[i].id)
 			self.map(ux, uy, Map.TERRAIN, self.grid_list[self:resolve("up")])

game/engine/generator/map/Rooms.lua

@@ -5,8 +5,9 @@ require "engine.Generator"
 --- Generator that makes a map
 module(..., package.seeall, class.inherit(engine.Generator))
 
-function _M:init(zone, map, grid_list, data)
-	engine.Generator.init(self, zone, map)
+function _M:init(zone, map, level, data)
+	engine.Generator.init(self, zone, map, level)
+	local grid_list = zone.grid_list
 	self.floor = grid_list[data.floor]
 	self.wall = grid_list[data.wall]
 	self.door = grid_list[data.door]

game/engine/generator/map/Static.lua

@@ -4,12 +4,11 @@ local Grid = require "engine.Grid"
 require "engine.Generator"
 module(..., package.seeall, class.inherit(engine.Generator))
 
-function _M:init(zone, map, grid_list, data)
-	engine.Generator.init(self, zone, map)
-	self.grid_list = grid_list
+function _M:init(zone, map, level, data)
+	engine.Generator.init(self, zone, map, level)
+	self.grid_list = zone.grid_list
 	self.subgen = {}
 	self.data = data
-
 	self:loadMap(data.map)
 end
 
@@ -76,7 +75,23 @@ end
 
 function _M:generate(lev, old_lev)
 	for i = 1, self.gen_map.w do for j = 1, self.gen_map.h do
-		self.map(i-1, j-1, Map.TERRAIN, self:resolve("grid", self.gen_map[i][j]))
+		local c = self.gen_map[i][j]
+		self.map(i-1, j-1, Map.TERRAIN, self:resolve("grid", c))
+
+		local actor = self.tiles[c].actor
+
+		if actor then
+			local m = self.zone:makeEntityByName(self.level, "actor", f)
+			if m then
+				m:move(x, y, true)
+				self.level:addEntity(m)
+				m:added()
+				if self.adjust_level then
+					local newlevel = self.adjust_level.base + rng.avg(self.adjust_level.min, self.adjust_level.max)
+					m:forceLevelup(newlevel)
+				end
+			end
+		end
 	end end
 
 	for i = 1, #self.subgen do
@@ -88,12 +103,13 @@ function _M:generate(lev, old_lev)
 		local generator = require(g.generator).new(
 			self.zone,
 			map,
-			self.grid_list,
+			self.level,
 			data
 		)
 		generator:generate(lev, old_lev)
 
 		self.map:import(map, g.x, g.y)
+		map:close()
 	end
 
 	return self.gen_map.startx, self.gen_map.starty, self.gen_map.startx, self.gen_map.starty

game/engine/generator/map/TileSet.lua

@@ -4,9 +4,9 @@ require "engine.Generator"
 module(..., package.seeall, class.inherit(engine.Generator))
 
 function _M:init(zone, map, grid_list, data)
-	engine.Generator.init(self, zone, map)
+	engine.Generator.init(self, zone, map, level)
 	self.data = data
-	self.grid_list = grid_list
+	self.grid_list = zone.grid_list
 	self.tiles, self.raw = self:loadTiles(data.tileset)
 	self.matching_tiles = {}
 

game/engine/generator/object/Random.lua

@@ -8,9 +8,6 @@ function _M:init(zone, map, level)
 	self.level = level
 	local data = level.data.generator.object
 
-	-- Setup the entities list
-	level:setEntitiesList("object", zone:computeRarities("object", zone.object_list, level, nil))
-
 	if data.adjust_level_to_player and game:getPlayer() then
 		self.adjust_level_to_player = {base=game:getPlayer().level, min=data.adjust_level_to_player[1], max=data.adjust_level_to_player[2]}
 	end

game/engine/generator/trap/Random.lua

@@ -8,9 +8,6 @@ function _M:init(zone, map, level)
 	self.level = level
 	local data = level.data.generator.trap
 
-	-- Setup the entities list
-	level:setEntitiesList("trap", zone:computeRarities("trap", zone.trap_list, level, nil))
-
 	self.filters = data.filters
 	self.nb_trap = data.nb_trap or {10, 20}
 	self.level_range = data.level_range or {level, level}

game/modules/tome/data/rooms/forest_clearing.lua

@@ -11,10 +11,10 @@ return function(gen, id)
 		for i = 1, self.w do
 			for j = 1, self.h do
 				if hm.hmap[i][j] >= Heightmap.max * 5 / 6 then
-					gen.room_map[i-1+x][j-1+y].can_open = true
+					gen.map.room_map[i-1+x][j-1+y].can_open = true
 					gen.map(i-1+x, j-1+y, Map.TERRAIN, gen.grid_list[gen:resolve('#')])
 				else
-					gen.room_map[i-1+x][j-1+y].room = id
+					gen.map.room_map[i-1+x][j-1+y].room = id
 					gen.map(i-1+x, j-1+y, Map.TERRAIN, gen.grid_list[gen:resolve('.')])
 				end
 				if is_lit then gen.map.lites(i-1+x, j-1+y, true) end

game/modules/tome/data/rooms/maze.lua

@@ -7,28 +7,29 @@ return function(gen, id, lev, old_lev)
 		local maze = Maze.new(gen.zone, map, gen.grid_list, gen.data)
 		maze:generate(lev, old_lev)
 		gen.map:import(map, x, y)
+		map:close()
 		-- Make it a room, and make it special so that we do not tunnel through
 		for i = x, x + w - 1 do for j = y, y + h - 1 do
-			gen.room_map[i][j].special = true
-			gen.room_map[i][j].room = id
+			gen.map.room_map[i][j].special = true
+			gen.map.room_map[i][j].room = id
 		end end
 
 		-- Mark the outer walls are piercable
 		for i = x, x + w - 1 do
-			gen.room_map[i][y].special = false
-			gen.room_map[i][y].room = nil
-			gen.room_map[i][y].can_open = true
-			gen.room_map[i][y+h-1].special = false
-			gen.room_map[i][y+h-1].room = nil
-			gen.room_map[i][y+h-1].can_open = true
+			gen.map.room_map[i][y].special = false
+			gen.map.room_map[i][y].room = nil
+			gen.map.room_map[i][y].can_open = true
+			gen.map.room_map[i][y+h-1].special = false
+			gen.map.room_map[i][y+h-1].room = nil
+			gen.map.room_map[i][y+h-1].can_open = true
 		end
 		for j = y, y + h - 1 do
-			gen.room_map[x][j].special = false
-			gen.room_map[x][j].room = nil
-			gen.room_map[x][j].can_open = true
-			gen.room_map[x+w-1][j].special = false
-			gen.room_map[x+w-1][j].room = nil
-			gen.room_map[x+w-1][j].can_open = true
+			gen.map.room_map[x][j].special = false
+			gen.map.room_map[x][j].room = nil
+			gen.map.room_map[x][j].can_open = true
+			gen.map.room_map[x+w-1][j].special = false
+			gen.map.room_map[x+w-1][j].room = nil
+			gen.map.room_map[x+w-1][j].can_open = true
 		end
 	end}
 end

game/modules/tome/data/rooms/simple.lua

@@ -5,10 +5,10 @@ return function(gen, id)
 		for i = 1, self.w do
 			for j = 1, self.h do
 				if i == 1 or i == self.w or j == 1 or j == self.h then
-					gen.room_map[i-1+x][j-1+y].can_open = true
+					gen.map.room_map[i-1+x][j-1+y].can_open = true
 					gen.map(i-1+x, j-1+y, Map.TERRAIN, gen.grid_list[gen:resolve('#')])
 				else
-					gen.room_map[i-1+x][j-1+y].room = id
+					gen.map.room_map[i-1+x][j-1+y].room = id
 					gen.map(i-1+x, j-1+y, Map.TERRAIN, gen.grid_list[gen:resolve('.')])
 				end
 				if is_lit then gen.map.lites(i-1+x, j-1+y, true) end