tgpholly/scpcb-godot
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

map gen almost works

Browse source
This commit is contained in:
Holly Stubbs 2025-02-10 07:41:41 +00:00
parent ef5c129272
commit b9a9cb6203
Signed by: tgpholly
GPG key ID: B8583C4B7D18119E
15 changed files with 745 additions and 283 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
scenes/screens/LoadingScreen.tscn
View file

@ -13,10 +13,12 @@ script = ExtResource("1_grr4e")
[node name="Background" type="TextureRect" parent="."] [node name="Background" type="TextureRect" parent="."]
visible = false visible = false
z_index = -1
layout_mode = 1 layout_mode = 1
expand_mode = 1 expand_mode = 1
[node name="LoadingImage" type="TextureRect" parent="."] [node name="LoadingImage" type="TextureRect" parent="."]
z_index = -1
layout_mode = 0 layout_mode = 0
offset_right = 40.0 offset_right = 40.0
offset_bottom = 40.0 offset_bottom = 40.0

6
scenes/world/DynamicMap.tscn
View file

@ -22,17 +22,17 @@ script = ExtResource("1_mytgt")
[node name="WorldEnvironment" type="WorldEnvironment" parent="."] [node name="WorldEnvironment" type="WorldEnvironment" parent="."]
environment = SubResource("Environment_d5g72") environment = SubResource("Environment_d5g72")
[node name="Player" parent="." instance=ExtResource("3_58gow")]
[node name="CameraPivot" type="Node3D" parent="."] [node name="CameraPivot" type="Node3D" parent="."]
visible = false
[node name="Camera3D" type="Camera3D" parent="CameraPivot"] [node name="Camera3D" type="Camera3D" parent="CameraPivot"]
current = true
script = ExtResource("2_co6fy") script = ExtResource("2_co6fy")
[node name="DirectionalLight3D" type="DirectionalLight3D" parent="."] [node name="DirectionalLight3D" type="DirectionalLight3D" parent="."]
transform = Transform3D(1, 0, 0, 0, -4.37114e-08, 1, 0, -1, -4.37114e-08, 0, 0, 0) transform = Transform3D(1, 0, 0, 0, -4.37114e-08, 1, 0, -1, -4.37114e-08, 0, 0, 0)
[node name="Player" parent="." instance=ExtResource("3_58gow")]
[node name="CSGBox3D" type="CSGBox3D" parent="."] [node name="CSGBox3D" type="CSGBox3D" parent="."]
transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, -0.97521, -1.86909, -3.06) transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, -0.97521, -1.86909, -3.06)
use_collision = true use_collision = true

1
scenes/world/Player.tscn
View file

@ -26,6 +26,7 @@ transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1.75, 0)
[node name="Collision" type="CollisionShape3D" parent="."] [node name="Collision" type="CollisionShape3D" parent="."]
transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0) transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0)
shape = SubResource("CylinderShape3D_bsew3") shape = SubResource("CylinderShape3D_bsew3")
disabled = true
[node name="MeshInstance3D" type="MeshInstance3D" parent="Collision"] [node name="MeshInstance3D" type="MeshInstance3D" parent="Collision"]
visible = false visible = false

17
src/Constants.gd Normal file
View file

@ -0,0 +1,17 @@
class_name Constants
const ZONEAMOUNT = 3
const MaxRoomLights = 32
const MaxRoomEmitters = 8
const MaxRoomObjects = 30
const ROOM1 = 1
const ROOM2 = 2
const ROOM2C = 3
const ROOM3 = 4
const ROOM4 = 5
const gridsz = 19 # Same size as the main map itself (better for the map creator)
const RoomScale = 0.010

613
src/DynamicMap.gd
View file

@ -1,28 +1,18 @@
extends Node3D extends Node3D
var roomTemplatesRaw = Dictionary()
func _ready() -> void: func _ready() -> void:
RMesh.LoadRMesh(self, "GFX\\map\\gatea_opt.rmesh") #add_child(RMesh.LoadRMesh("GFX\\map\\gatea_opt.rmesh", RoomTemplate.new()))
#B3D.Load("GFX\\npcs\\106_2.b3d") #B3D.Load("GFX\\npcs\\106_2.b3d")
add_child(B3D.Load("GFX\\apache.b3d")) #add_child(B3D.Load("GFX\\apache.b3d"))
var rooms = INI.Load("res://Data/rooms.ini")
for room in rooms:
if room == "loose":
continue
if room == "room ambience":
continue
var roomInfo = rooms[room]
if not roomInfo.has("mesh path"):
print(room, roomInfo)
continue
roomTemplatesRaw.get_or_add(room, roomInfo)
#RMesh.LoadRMesh(self, roomInfo["mesh path"]) #RMesh.LoadRMesh(self, roomInfo["mesh path"])
#CreateMap() #CreateMap()
IntroEnabled = true
LoadRoomTemplates("Data\\rooms.ini")
CreateMap()
var IntroEnabled: bool
var I_Zone: MapZones = MapZones.new() var I_Zone: MapZones = MapZones.new()
var RandomSeed: String = "" var RandomSeed: String = ""
@ -35,20 +25,78 @@ const HideDistance = 15.0
var MapTemp = Utils.Init2DArray(MapWidth + 1, MapHeight + 1, 0) var MapTemp = Utils.Init2DArray(MapWidth + 1, MapHeight + 1, 0)
var MapFound = Utils.Init2DArray(MapWidth + 1, MapHeight + 1, 0) var MapFound = Utils.Init2DArray(MapWidth + 1, MapHeight + 1, 0)
const ZONEAMOUNT = 3 var RoomTempID = 0
var RoomAmbience = Utils.Init1DArray(20)
var RoomTemplates: Array
const ROOM1 = 1 func CreateRoomTemplate(meshpath: String):
const ROOM2 = 2 var rt = RoomTemplate.new()
const ROOM2C = 3 RoomTemplates.push_back(rt)
const ROOM3 = 4
const ROOM4 = 5 rt.objPath = meshpath
rt.id = RoomTempID
RoomTempID += 1
return rt
func LoadRoomTemplates(file: String):
var TemporaryString: String
var i: int
RoomTemplates = []
var StrTemp: String = ""
var rtRaw = INI.Load(str("res://Data/rooms.ini"))
for templateName in rtRaw:
if templateName == "room ambience":
continue
var template = rtRaw[templateName]
StrTemp = template["mesh path"]
var rt = CreateRoomTemplate(StrTemp)
RoomTemplates.push_back(rt)
rt.Name = TemporaryString.to_lower()
StrTemp = template["shape"].to_lower()
match StrTemp:
"room1", "1":
rt.Shape = Constants.ROOM1
"room2", "2":
rt.Shape = Constants.ROOM2
"room2c", "2c":
rt.Shape = Constants.ROOM2C
"room3", "3":
rt.Shape = Constants.ROOM3
"room4", "4":
rt.Shape = Constants.ROOM4
for i1 in range(4):
rt.zone[i1] = INI.GetInt(template, str("zone", (i1 + 1)))
rt.Commonness = max(min(INI.GetInt(template, "commonness"), 100), 0)
rt.Large = INI.GetBool(template, "large")
rt.DisableDecals = INI.GetBool(template, "disabledecals")
rt.UseLightCones = INI.GetBool(template, "usevolumelighting")
rt.DisableOverlapCheck = INI.GetBool(template, "disableoverlapcheck")
i = 1
while true:
StrTemp = INI.GetString(rtRaw["room ambience"], str("ambience", i))
if StrTemp == "":
break
RoomAmbience[i] = load(Utils.GetCaseiFileName(str("res://", StrTemp.replace("\\", "/"))))
i += 1
var MapRoom: Array var MapRoom: Array
var MapName = Utils.Init2DArray(MapWidth, MapHeight, "") var MapName = Utils.Init2DArray(MapWidth, MapHeight, "")
var MapRoomID = Utils.Init1DArray(ROOM4 + 1, 0) var MapRoomID = Utils.Init1DArray(Constants.ROOM4 + 1, 0)
func GetZone(y): func GetZone(y):
return min(floor((float(MapWidth - y) / MapWidth * ZONEAMOUNT)), ZONEAMOUNT -1) return min(floor((float(MapWidth - y) / MapWidth * Constants.ZONEAMOUNT)), Constants.ZONEAMOUNT -1)
func SetRoom(room_name, room_type, pos, min_pos, max_pos): # place a room without overwriting others func SetRoom(room_name, room_type, pos, min_pos, max_pos): # place a room without overwriting others
if max_pos < min_pos: if max_pos < min_pos:
@ -79,6 +127,148 @@ func SetRoom(room_name, room_type, pos, min_pos, max_pos): # place a room withou
print(str("couldn't place ", room_name)) print(str("couldn't place ", room_name))
return false return false
func CalculateRoomTemplateExtents(r: RoomTemplate):
if r.DisableOverlapCheck:
return
#GetMeshExtents(GetChild(r\obj,2))
var aabb = Utils.get_node_aabb(r.obj)
r.MinX = aabb.position.x
r.MinY = aabb.position.y
r.MinZ = aabb.position.z
r.MaxX = aabb.size.x
r.MaxY = aabb.size.y
r.MaxZ = aabb.size.z
print("roomtemplateextents: ", r.MinX, ", ", r.MinY, ", ", r.MinZ, ", ", r.MaxX, ", ", r.MaxY, ", ", r.MaxZ)
func CalculateRoomExtents(r: Room):
if r.RoomTemplate.DisableOverlapCheck:
return
# shrink the extents slightly - we don't care if the overlap is smaller than the thickness of the walls
var shrinkAmount = 0.05
# convert from the rooms local space to world space
#TFormVector(r.RoomTemplate.MinX, r.RoomTemplate.MinY, r.RoomTemplate.MinZ, r.obj, 0)
#r\MinX = TFormedX() + shrinkAmount + r\x
#r\MinY = TFormedY() + shrinkAmount
#r\MinZ = TFormedZ() + shrinkAmount + r\z
r.MinX = r.RoomTemplate.MinX + shrinkAmount + r.x
r.MinY = r.RoomTemplate.MinY + shrinkAmount
r.MinZ = r.RoomTemplate.MinZ + shrinkAmount + r.z
# convert from the rooms local space to world space
#TFormVector(r\RoomTemplate\MaxX, r\RoomTemplate\MaxY, r\RoomTemplate\MaxZ, r\obj, 0)
#r\MaxX = TFormedX() - shrinkAmount + r\x
#r\MaxY = TFormedY() - shrinkAmount
#r\MaxZ = TFormedZ() - shrinkAmount + r\z
r.MaxX = r.RoomTemplate.MaxX - shrinkAmount + r.x
r.MaxY = r.RoomTemplate.MaxY - shrinkAmount
r.MaxZ = r.RoomTemplate.MaxZ - shrinkAmount + r.z
if r.MinX > r.MaxX:
var tempX = r.MaxX
r.MaxX = r.MinX
r.MinX = tempX
if r.MinZ > r.MaxZ:
var tempZ = r.MaxZ
r.MaxZ = r.MinZ
r.MinZ = tempZ
print("roomextents: ", r.MinX, ", ", r.MinY, ", ", r.MinZ, ", ", r.MaxX, ", ", r.MaxY, ", ", r.MaxZ)
func LoadRoomMesh(rt: RoomTemplate):
if rt.objPath.contains(".rmesh"): # file is roommesh
rt.obj = RMesh.LoadRMesh(rt.objPath, rt)
# TODO: Implement b3d maps, not pressing as newer vers use exclusively rmesh
#else: #file is b3d
#If rt\objPath <> "" Then rt\obj = LoadWorld(rt\objPath, rt) Else rt\obj = CreatePivot()
if not rt.obj:
assert(str("Failed to load map file \"", rt.objPath, "\"."))
CalculateRoomTemplateExtents(rt)
# NOTE: Probably not needed, works different here to b3d.
#HideEntity(rt\obj)
var rooms:Array = []
func CreateRoom(zone, roomshape, x, y, z, name = ""):
var r = Room.new()
rooms.push_back(r)
r.zone = zone
r.x = x
r.y = y
r.z = z
if name != "":
name = name.to_lower()
for rt: RoomTemplate in RoomTemplates:
if rt.Name == name:
r.RoomTemplate = rt
if rt.obj == null: # 0
LoadRoomMesh(rt)
r.obj = rt.obj.duplicate()
add_child(r.obj)
#ScaleEntity(r\obj, RoomScale, RoomScale, RoomScale)
#EntityType(r\obj, HIT_MAP)
#EntityPickMode(r\obj, 2)
r.obj.position = Vector3(x, y, z)
# TODO: oh good god it's long.
#FillRoom(r)
# TODO:
#if r.RoomTemplate.UseLightCones:
#AddLightCones(r)
#EndIf
CalculateRoomExtents(r)
return r
var temp = 0
for rt: RoomTemplate in RoomTemplates:
for i in range(4):
if rt.zone[i] == zone:
if rt.Shape == roomshape:
temp += rt.Commonness
break
#var RandomRoom = Rand(temp)
var RandomRoom = randi_range(1, temp)
temp = 0
for rt: RoomTemplate in RoomTemplates:
for i in range(4):
if rt.zone[i] == zone and rt.Shape == roomshape:
temp += rt.Commonness
if RandomRoom > temp - rt.Commonness and RandomRoom <= temp:
r.RoomTemplate = rt
if rt.obj == null:
LoadRoomMesh(rt)
r.obj = rt.obj.duplicate()
add_child(r.obj)
#ScaleEntity(r\obj, RoomScale, RoomScale, RoomScale)
#EntityType(r\obj, HIT_MAP)
#EntityPickMode(r\obj, 2)
r.obj.position = Vector3(x, y, z)
# TODO: :c
#FillRoom(r)
# TODO:
#if r.RoomTemplate.UseLightCones:
#AddLightCones(r)
CalculateRoomExtents(r)
return r
func CreateMap(): func CreateMap():
print(str("Generating a map using the seed ", RandomSeed)) print(str("Generating a map using the seed ", RandomSeed))
@ -104,7 +294,7 @@ func CreateMap():
x = floor(MapWidth / 2) x = floor(MapWidth / 2)
y = MapHeight - 2 # Rand(3, 5) y = MapHeight - 2 # Rand(3, 5)
for i1 in range(y, MapHeight - 1): for i1 in range(y, MapHeight): # MapHeight - 1
MapTemp[x][i1] = 1 MapTemp[x][i1] = 1
while y < 2: while y < 2:
@ -173,7 +363,7 @@ func CreateMap():
# count the amount of rooms # count the amount of rooms
#For y = 1 To MapHeight - 1 #For y = 1 To MapHeight - 1
for y1 in range(MapHeight): for y1 in range(MapHeight):
zone = GetZone(y) zone = GetZone(y1)
for x1 in range(MapWidth): for x1 in range(MapWidth):
if MapTemp[x1][y1] > 0: if MapTemp[x1][y1] > 0:
@ -181,7 +371,7 @@ func CreateMap():
temp = temp + min(MapTemp[x1][y1 + 1], 1) + min(MapTemp[x1][y1 - 1], 1) temp = temp + min(MapTemp[x1][y1 + 1], 1) + min(MapTemp[x1][y1 - 1], 1)
if MapTemp[x1][y1] < 255: if MapTemp[x1][y1] < 255:
MapTemp[x1][y1] = temp MapTemp[x1][y1] = temp
print(MapTemp[x1][y1]) #print(MapTemp[x1][y1])
match MapTemp[x1][y1]: match MapTemp[x1][y1]:
1: 1:
Room1Amount[zone] += 1 Room1Amount[zone] += 1
@ -210,18 +400,18 @@ func CreateMap():
for y1 in range((MapHeight/ZoneAmount) * (2 - i) + 1, ((MapHeight/ZoneAmount) * ((2 - i) + 1.0)) - 2): for y1 in range((MapHeight/ZoneAmount) * (2 - i) + 1, ((MapHeight/ZoneAmount) * ((2 - i) + 1.0)) - 2):
for x1 in range(2, MapWidth - 2): for x1 in range(2, MapWidth - 2):
if MapTemp[x1][y1] == 0: if MapTemp[x1][y1] == 0:
if (min(MapTemp[x1 + 1][y], 1) + min(MapTemp[x1 - 1][y1], 1) + min(MapTemp[x1][y1 + 1], 1) + min(MapTemp[x1][y1 - 1], 1)) == 1: if (min(MapTemp[x1 + 1][y1], 1) + min(MapTemp[x1 - 1][y1], 1) + min(MapTemp[x1][y1 + 1], 1) + min(MapTemp[x1][y1 - 1], 1)) == 1:
#If Rand(4)=1 Then #If Rand(4)=1 Then
if MapTemp[x1 + 1][y]: if MapTemp[x1 + 1][y1]:
x2 = x1 + 1 x2 = x1 + 1
y2 = y1 y2 = y1
elif MapTemp[x - 1][y]: elif MapTemp[x1 - 1][y1]:
x2 = x1 - 1 x2 = x1 - 1
y2 = y1 y2 = y1
elif MapTemp[x][y + 1]: elif MapTemp[x1][y1 + 1]:
x2 = x1 x2 = x1
y2 = y1 + 1 y2 = y1 + 1
elif MapTemp[x][y-1]: elif MapTemp[x1][y1-1]:
x2 = x1 x2 = x1
y2 = y1 - 1 y2 = y1 - 1
@ -380,227 +570,218 @@ func CreateMap():
MaxRooms = max(MaxRooms, Room2CAmount[0] + Room2CAmount[1] + Room2CAmount[2] + 1) MaxRooms = max(MaxRooms, Room2CAmount[0] + Room2CAmount[1] + Room2CAmount[2] + 1)
MaxRooms = max(MaxRooms, Room3Amount[0] + Room3Amount[1] + Room3Amount[2] + 1) MaxRooms = max(MaxRooms, Room3Amount[0] + Room3Amount[1] + Room3Amount[2] + 1)
MaxRooms = max(MaxRooms, Room4Amount[0] + Room4Amount[1] + Room4Amount[2] + 1) MaxRooms = max(MaxRooms, Room4Amount[0] + Room4Amount[1] + Room4Amount[2] + 1)
MapRoom = Utils.Init2DArray(ROOM4 + 1, MaxRooms) MapRoom = Utils.Init2DArray(Constants.ROOM4 + 1, MaxRooms)
# zone 1 -------------------------------------------------------------------------------------------------- # zone 1 --------------------------------------------------------------------------------------------------
var min_pos = 1 var min_pos = 1
var max_pos = Room1Amount[0] - 1 var max_pos = Room1Amount[0] - 1
MapRoom[ROOM1][0] = "start" MapRoom[Constants.ROOM1][0] = "start"
SetRoom("roompj", ROOM1, floor(0.1 * float(Room1Amount[0])), min_pos,max_pos) SetRoom("roompj", Constants.ROOM1, floor(0.1 * float(Room1Amount[0])), min_pos,max_pos)
SetRoom("914", ROOM1, floor(0.3 * float(Room1Amount[0])), min_pos, max_pos) SetRoom("914", Constants.ROOM1, floor(0.3 * float(Room1Amount[0])), min_pos, max_pos)
SetRoom("room1archive",ROOM1,floor(0.5 * float(Room1Amount[0])), min_pos, max_pos) SetRoom("room1archive", Constants.ROOM1, floor(0.5 * float(Room1Amount[0])), min_pos, max_pos)
SetRoom("room205", ROOM1, floor(0.6 * float(Room1Amount[0])), min_pos, max_pos) SetRoom("room205", Constants.ROOM1, floor(0.6 * float(Room1Amount[0])), min_pos, max_pos)
MapRoom[ROOM2C][0] = "lockroom" MapRoom[Constants.ROOM2C][0] = "lockroom"
min_pos = 1 min_pos = 1
max_pos = Room2Amount[0]-1 max_pos = Room2Amount[0]-1
MapRoom[ROOM2][0] = "room2closets" MapRoom[Constants.ROOM2][0] = "room2closets"
SetRoom("room2testroom2", ROOM2, floor(0.1 * float(Room2Amount[0])), min_pos, max_pos) SetRoom("room2testroom2", Constants.ROOM2, floor(0.1 * float(Room2Amount[0])), min_pos, max_pos)
SetRoom("room2scps", ROOM2, floor(0.2 * float(Room2Amount[0])), min_pos, max_pos) SetRoom("room2scps", Constants.ROOM2, floor(0.2 * float(Room2Amount[0])), min_pos, max_pos)
SetRoom("room2storage", ROOM2, floor(0.3 * float(Room2Amount[0])), min_pos, max_pos) SetRoom("room2storage", Constants.ROOM2, floor(0.3 * float(Room2Amount[0])), min_pos, max_pos)
SetRoom("room2gw_b", ROOM2, floor(0.4 * float(Room2Amount[0])), min_pos, max_pos) SetRoom("room2gw_b", Constants.ROOM2, floor(0.4 * float(Room2Amount[0])), min_pos, max_pos)
SetRoom("room2sl", ROOM2, floor(0.5 * float(Room2Amount[0])), min_pos, max_pos) SetRoom("room2sl", Constants.ROOM2, floor(0.5 * float(Room2Amount[0])), min_pos, max_pos)
SetRoom("room012", ROOM2, floor(0.55 * float(Room2Amount[0])), min_pos, max_pos) SetRoom("room012", Constants.ROOM2, floor(0.55 * float(Room2Amount[0])), min_pos, max_pos)
SetRoom("room2scps2", ROOM2, floor(0.6 * float(Room2Amount[0])), min_pos, max_pos) SetRoom("room2scps2", Constants.ROOM2, floor(0.6 * float(Room2Amount[0])), min_pos, max_pos)
SetRoom("room1123", ROOM2, floor(0.7 * float(Room2Amount[0])), min_pos, max_pos) SetRoom("room1123", Constants.ROOM2, floor(0.7 * float(Room2Amount[0])), min_pos, max_pos)
SetRoom("room2elevator", ROOM2, floor(0.85 * float(Room2Amount[0])), min_pos, max_pos) SetRoom("room2elevator", Constants.ROOM2, floor(0.85 * float(Room2Amount[0])), min_pos, max_pos)
MapRoom[ROOM3][floor(randf_range(0.2, 0.8) * float(Room3Amount[0]))] = "room3storage" MapRoom[Constants.ROOM3][floor(randf_range(0.2, 0.8) * float(Room3Amount[0]))] = "room3storage"
MapRoom[ROOM2C][floor(0.5 * float(Room2CAmount[0]))] = "room1162" MapRoom[Constants.ROOM2C][floor(0.5 * float(Room2CAmount[0]))] = "room1162"
MapRoom[ROOM4][floor(0.3 * float(Room4Amount[0]))] = "room4info" MapRoom[Constants.ROOM4][floor(0.3 * float(Room4Amount[0]))] = "room4info"
# zone 2 -------------------------------------------------------------------------------------------------- # zone 2 --------------------------------------------------------------------------------------------------
min_pos = Room1Amount[0] min_pos = Room1Amount[0]
max_pos = Room1Amount[0] + Room1Amount[1] - 1 max_pos = Room1Amount[0] + Room1Amount[1] - 1
SetRoom("room079", ROOM1, Room1Amount[0] + floor(0.15 * float(Room1Amount[1])), min_pos, max_pos) SetRoom("room079", Constants.ROOM1, Room1Amount[0] + floor(0.15 * float(Room1Amount[1])), min_pos, max_pos)
SetRoom("room106", ROOM1, Room1Amount[0] + floor(0.3 * float(Room1Amount[1])), min_pos, max_pos) SetRoom("room106", Constants.ROOM1, Room1Amount[0] + floor(0.3 * float(Room1Amount[1])), min_pos, max_pos)
SetRoom("008", ROOM1, Room1Amount[0] + floor(0.4 * float(Room1Amount[1])), min_pos, max_pos) SetRoom("008", Constants.ROOM1, Room1Amount[0] + floor(0.4 * float(Room1Amount[1])), min_pos, max_pos)
SetRoom("room035", ROOM1, Room1Amount[0] + floor(0.5 * float(Room1Amount[1])), min_pos, max_pos) SetRoom("room035", Constants.ROOM1, Room1Amount[0] + floor(0.5 * float(Room1Amount[1])), min_pos, max_pos)
SetRoom("coffin", ROOM1, Room1Amount[0] + floor(0.7 * float(Room1Amount[1])), min_pos, max_pos) SetRoom("coffin", Constants.ROOM1, Room1Amount[0] + floor(0.7 * float(Room1Amount[1])), min_pos, max_pos)
min_pos = Room2Amount[0] min_pos = Room2Amount[0]
max_pos = Room2Amount[0] + Room2Amount[1] - 1 max_pos = Room2Amount[0] + Room2Amount[1] - 1
MapRoom[ROOM2][Room2Amount[0] + floor(0.1 * float(Room2Amount[1]))] = "room2nuke" MapRoom[Constants.ROOM2][Room2Amount[0] + floor(0.1 * float(Room2Amount[1]))] = "room2nuke"
SetRoom("room2tunnel", ROOM2, Room2Amount[0] + floor(0.25 * float(Room2Amount[1])), min_pos, max_pos) SetRoom("room2tunnel", Constants.ROOM2, Room2Amount[0] + floor(0.25 * float(Room2Amount[1])), min_pos, max_pos)
SetRoom("room049", ROOM2, Room2Amount[0] + floor(0.4 * float(Room2Amount[1])),min_pos,max_pos) SetRoom("room049", Constants.ROOM2, Room2Amount[0] + floor(0.4 * float(Room2Amount[1])),min_pos,max_pos)
SetRoom("room2shaft",ROOM2,Room2Amount[0] + floor(0.6 * float(Room2Amount[1])), min_pos, max_pos) SetRoom("room2shaft", Constants.ROOM2,Room2Amount[0] + floor(0.6 * float(Room2Amount[1])), min_pos, max_pos)
SetRoom("testroom", ROOM2, Room2Amount[0] + floor(0.7 * float(Room2Amount[1])), min_pos, max_pos) SetRoom("testroom", Constants.ROOM2, Room2Amount[0] + floor(0.7 * float(Room2Amount[1])), min_pos, max_pos)
SetRoom("room2servers", ROOM2, Room2Amount[0] + floor(0.9 * Room2Amount[1]), min_pos, max_pos) SetRoom("room2servers", Constants.ROOM2, Room2Amount[0] + floor(0.9 * Room2Amount[1]), min_pos, max_pos)
MapRoom[ROOM3][Room3Amount[0] + floor(0.3 * float(Room3Amount[1]))] = "room513" MapRoom[Constants.ROOM3][Room3Amount[0] + floor(0.3 * float(Room3Amount[1]))] = "room513"
MapRoom[ROOM3][Room3Amount[0] + floor(0.6 * float(Room3Amount[1]))] = "room966" MapRoom[Constants.ROOM3][Room3Amount[0] + floor(0.6 * float(Room3Amount[1]))] = "room966"
MapRoom[ROOM2C][Room2CAmount[0] + floor(0.5 * float(Room2CAmount[1]))] = "room2cpit" MapRoom[Constants.ROOM2C][Room2CAmount[0] + floor(0.5 * float(Room2CAmount[1]))] = "room2cpit"
# zone 3 -------------------------------------------------------------------------------------------------- # zone 3 --------------------------------------------------------------------------------------------------
MapRoom[ROOM1][Room1Amount[0] + Room1Amount[1] + Room1Amount[2] - 2] = "exit1" MapRoom[Constants.ROOM1][Room1Amount[0] + Room1Amount[1] + Room1Amount[2] - 2] = "exit1"
MapRoom[ROOM1][Room1Amount[0] + Room1Amount[1] + Room1Amount[2] - 1] = "gateaentrance" MapRoom[Constants.ROOM1][Room1Amount[0] + Room1Amount[1] + Room1Amount[2] - 1] = "gateaentrance"
MapRoom[ROOM1][Room1Amount[0] + Room1Amount[1]] = "room1lifts" MapRoom[Constants.ROOM1][Room1Amount[0] + Room1Amount[1]] = "room1lifts"
min_pos = Room2Amount[0] + Room2Amount[1] min_pos = Room2Amount[0] + Room2Amount[1]
max_pos = Room2Amount[0] + Room2Amount[1]+Room2Amount[2] - 1 max_pos = Room2Amount[0] + Room2Amount[1]+Room2Amount[2] - 1
MapRoom[ROOM2][min_pos + floor(0.1 * float(Room2Amount[2]))] = "room2poffices" MapRoom[Constants.ROOM2][min_pos + floor(0.1 * float(Room2Amount[2]))] = "room2poffices"
SetRoom("room2cafeteria", ROOM2, min_pos + floor(0.2 * float(Room2Amount[2])), min_pos, max_pos) SetRoom("room2cafeteria", Constants.ROOM2, min_pos + floor(0.2 * float(Room2Amount[2])), min_pos, max_pos)
SetRoom("room2sroom", ROOM2, min_pos + floor(0.3 * float(Room2Amount[2])), min_pos, max_pos) SetRoom("room2sroom", Constants.ROOM2, min_pos + floor(0.3 * float(Room2Amount[2])), min_pos, max_pos)
SetRoom("room2servers2", ROOM2, min_pos + floor(0.4 * Room2Amount[2]), min_pos, max_pos) SetRoom("room2servers2", Constants.ROOM2, min_pos + floor(0.4 * Room2Amount[2]), min_pos, max_pos)
SetRoom("room2offices", ROOM2, min_pos + floor(0.45 * Room2Amount[2]), min_pos, max_pos) SetRoom("room2offices", Constants.ROOM2, min_pos + floor(0.45 * Room2Amount[2]), min_pos, max_pos)
SetRoom("room2offices4", ROOM2, min_pos + floor(0.5 * Room2Amount[2]), min_pos, max_pos) SetRoom("room2offices4", Constants.ROOM2, min_pos + floor(0.5 * Room2Amount[2]), min_pos, max_pos)
SetRoom("room860", ROOM2, min_pos + floor(0.6 * Room2Amount[2]), min_pos, max_pos) SetRoom("room860", Constants.ROOM2, min_pos + floor(0.6 * Room2Amount[2]), min_pos, max_pos)
SetRoom("medibay", ROOM2, min_pos + floor(0.7 * float(Room2Amount[2])), min_pos, max_pos) SetRoom("medibay", Constants.ROOM2, min_pos + floor(0.7 * float(Room2Amount[2])), min_pos, max_pos)
SetRoom("room2poffices2", ROOM2, min_pos + floor(0.8 * Room2Amount[2]), min_pos, max_pos) SetRoom("room2poffices2", Constants.ROOM2, min_pos + floor(0.8 * Room2Amount[2]), min_pos, max_pos)
SetRoom("room2offices2", ROOM2, min_pos + floor(0.9 * float(Room2Amount[2])), min_pos, max_pos) SetRoom("room2offices2", Constants.ROOM2, min_pos + floor(0.9 * float(Room2Amount[2])), min_pos, max_pos)
MapRoom[ROOM2C][Room2CAmount[0] + Room2CAmount[1]] = "room2ccont" MapRoom[Constants.ROOM2C][Room2CAmount[0] + Room2CAmount[1]] = "room2ccont"
MapRoom[ROOM2C][Room2CAmount[0] + Room2CAmount[1] + 1] = "lockroom2" MapRoom[Constants.ROOM2C][Room2CAmount[0] + Room2CAmount[1] + 1] = "lockroom2"
MapRoom[ROOM3][Room3Amount[0] + Room3Amount[1] + floor(0.3 * float(Room3Amount[2]))] = "room3servers" MapRoom[Constants.ROOM3][Room3Amount[0] + Room3Amount[1] + floor(0.3 * float(Room3Amount[2]))] = "room3servers"
MapRoom[ROOM3][Room3Amount[0] + Room3Amount[1] + floor(0.7 * float(Room3Amount[2]))] = "room3servers2" MapRoom[Constants.ROOM3][Room3Amount[0] + Room3Amount[1] + floor(0.7 * float(Room3Amount[2]))] = "room3servers2"
#MapRoom(ROOM3, Room3Amount[0]+Room3Amount[1]) = "room3gw" #MapRoom(ROOM3, Room3Amount[0]+Room3Amount[1]) = "room3gw"
MapRoom[ROOM3][Room3Amount[0] + Room3Amount[1] + floor(0.5 * float(Room3Amount[2]))] = "room3offices" MapRoom[Constants.ROOM3][Room3Amount[0] + Room3Amount[1] + floor(0.5 * float(Room3Amount[2]))] = "room3offices"
print(MapRoom)
#----------------------- creating the map -------------------------------- #----------------------- creating the map --------------------------------
#temp = 0 temp = 0
#Local r.Rooms, spacing# = 8.0 var r: Room
#For y = MapHeight - 1 To 1 Step - 1 var spacing = 8.0
# for y1 in range(MapHeight - 1, 1, -1):
#;zone% = GetZone(y) zone = GetZone(y1)
#
#If y < MapHeight/3+1 Then if y1 < MapHeight / 3 + 1:
#zone=3 zone = 3
#ElseIf y < MapHeight*(2.0/3.0);-1 elif y1 < MapHeight * (2.0 / 3.0):
#zone=2 zone=2
#Else else:
#zone=1 zone=1
#EndIf
# for x1 in range(MapWidth - 2):
#For x = 1 To MapWidth - 2 if MapTemp[x1][y1] == 255:
#If MapTemp(x, y) = 255 Then if y1 > MapHeight / 2: # zone = 2
#If y>MapHeight/2 Then ;zone = 2 r = CreateRoom(zone, Constants.ROOM2, x1 * 8, 0, y1 * 8, "checkpoint1")
#r = CreateRoom(zone, ROOM2, x * 8, 0, y * 8, "checkpoint1") else: #zone = 3
#Else ;If zone = 3 r = CreateRoom(zone, Constants.ROOM2, x1 * 8, 0, y1 * 8, "checkpoint2")
#r = CreateRoom(zone, ROOM2, x * 8, 0, y * 8, "checkpoint2") elif MapTemp[x1][y1] > 0:
#EndIf temp = min(MapTemp[x1 + 1][y1], 1) + min(MapTemp[x1 - 1][y1], 1) + min(MapTemp[x1][y1 + 1], 1) + min(MapTemp[x1][y1 - 1], 1)
#ElseIf MapTemp(x, y) > 0
# match temp: # viereisiss<73> ruuduissa olevien huoneiden m<><6D>r<EFBFBD>
#temp = Min(MapTemp(x + 1, y),1) + Min(MapTemp(x - 1, y),1) + Min(MapTemp(x, y + 1),1) + Min(MapTemp(x, y - 1),1) 1:
# if MapRoomID[Constants.ROOM1] < MaxRooms and MapName[x1][y1] == "":
#Select temp ;viereisiss<73> ruuduissa olevien huoneiden m<><6D>r<EFBFBD> if MapRoom[Constants.ROOM1][MapRoomID[Constants.ROOM1]] != "":
#Case 1 MapName[x1][y1] = MapRoom[Constants.ROOM1][MapRoomID[Constants.ROOM1]]
#If MapRoomID(ROOM1) < MaxRooms And MapName(x,y) = "" Then
#If MapRoom(ROOM1, MapRoomID(ROOM1)) <> "" Then MapName(x, y) = MapRoom(ROOM1, MapRoomID(ROOM1)) r = CreateRoom(zone, Constants.ROOM1, x1 * 8, 0, y1 * 8, MapName[x1][y1])
#EndIf if MapTemp[x1][y1 + 1]:
# r.angle = 180
#r = CreateRoom(zone, ROOM1, x * 8, 0, y * 8, MapName(x, y)) r.obj.rotation.y = deg_to_rad(r.angle)
#If MapTemp(x, y + 1) Then elif MapTemp[x1 - 1][y1]:
#r\angle = 180 r.angle = 270
#TurnEntity(r\obj, 0, r\angle, 0) r.obj.rotation.y = deg_to_rad(r.angle)
#ElseIf MapTemp(x - 1, y) elif MapTemp[x1 + 1][y1]:
#r\angle = 270 r.angle = 90
#TurnEntity(r\obj, 0, r\angle, 0) r.obj.rotation.y = deg_to_rad(r.angle)
#ElseIf MapTemp(x + 1, y) else:
#r\angle = 90 r.angle = 0
#TurnEntity(r\obj, 0, r\angle, 0) MapRoomID[Constants.ROOM1] = MapRoomID[Constants.ROOM1] + 1
#Else 2:
#r\angle = 0 if MapTemp[x1 - 1][y1] > 0 and MapTemp[x1 + 1][y1] > 0:
#End If if MapRoomID[Constants.ROOM2] < MaxRooms and MapName[x1][y1] == "":
#MapRoomID(ROOM1)=MapRoomID(ROOM1)+1 if MapRoom[Constants.ROOM2][MapRoomID[Constants.ROOM2]] != "":
#Case 2 MapName[x1][y1] = MapRoom[Constants.ROOM2][MapRoomID[Constants.ROOM2]]
#If MapTemp(x - 1, y)>0 And MapTemp(x + 1, y)>0 Then r = CreateRoom(zone, Constants.ROOM2, x1 * 8, 0, y1 * 8, MapName[x1][y1])
#If MapRoomID(ROOM2) < MaxRooms And MapName(x,y) = "" Then if randi_range(1, 2) == 1:
#If MapRoom(ROOM2, MapRoomID(ROOM2)) <> "" Then MapName(x, y) = MapRoom(ROOM2, MapRoomID(ROOM2)) r.angle = 90
#EndIf else:
#r = CreateRoom(zone, ROOM2, x * 8, 0, y * 8, MapName(x, y)) r.angle = 270
#If Rand(2) = 1 Then r\angle = 90 Else r\angle = 270 r.obj.rotation.y = deg_to_rad(r.angle)
#TurnEntity(r\obj, 0, r\angle, 0) MapRoomID[Constants.ROOM2] = MapRoomID[Constants.ROOM2] + 1
#MapRoomID(ROOM2)=MapRoomID(ROOM2)+1 elif MapTemp[x1][y1 - 1] > 0 and MapTemp[x1][y1 + 1] > 0:
#ElseIf MapTemp(x, y - 1)>0 And MapTemp(x, y + 1)>0 if MapRoomID[Constants.ROOM2] < MaxRooms and MapName[x1][y1] == "":
#If MapRoomID(ROOM2) < MaxRooms And MapName(x,y) = "" Then if MapRoom[Constants.ROOM2][MapRoomID[Constants.ROOM2]] != "":
#If MapRoom(ROOM2, MapRoomID(ROOM2)) <> "" Then MapName(x, y) = MapRoom(ROOM2, MapRoomID(ROOM2)) MapName[x1][y1] = MapRoom[Constants.ROOM2][MapRoomID[Constants.ROOM2]]
#EndIf r = CreateRoom(zone, Constants.ROOM2, x1 * 8, 0, y1 * 8, MapName[x1][y1])
#r = CreateRoom(zone, ROOM2, x * 8, 0, y * 8, MapName(x, y)) if randi_range(1, 2) == 1:
#If Rand(2) = 1 Then r\angle = 180 Else r\angle = 0 r.angle = 180
#TurnEntity(r\obj, 0, r\angle, 0) else:
#MapRoomID(ROOM2)=MapRoomID(ROOM2)+1 r.angle = 0
#Else r.obj.rotation.y = deg_to_rad(r.angle)
#If MapRoomID(ROOM2C) < MaxRooms And MapName(x,y) = "" Then MapRoomID[Constants.ROOM2] = MapRoomID[Constants.ROOM2] + 1
#If MapRoom(ROOM2C, MapRoomID(ROOM2C)) <> "" Then MapName(x, y) = MapRoom(ROOM2C, MapRoomID(ROOM2C)) else:
#EndIf if MapRoomID[Constants.ROOM2C] < MaxRooms and MapName[x1][y1] == "":
# if MapRoom[Constants.ROOM2C][MapRoomID[Constants.ROOM2C]] != "":
#If MapTemp(x - 1, y)>0 And MapTemp(x, y + 1)>0 Then MapName[x1][y1] = MapRoom[Constants.ROOM2C][MapRoomID[Constants.ROOM2C]]
#r = CreateRoom(zone, ROOM2C, x * 8, 0, y * 8, MapName(x, y))
#r\angle = 180 if MapTemp[x1 - 1][y1] > 0 and MapTemp[x1][y1 + 1] > 0:
#TurnEntity(r\obj, 0, r\angle, 0) r = CreateRoom(zone, Constants.ROOM2C, x1 * 8, 0, y1 * 8, MapName[x1][y1])
#ElseIf MapTemp(x + 1, y)>0 And MapTemp(x, y + 1)>0 r.angle = 180
#r = CreateRoom(zone, ROOM2C, x * 8, 0, y * 8, MapName(x, y)) r.obj.rotation.y = deg_to_rad(r.angle)
#r\angle = 90 elif MapTemp[x1 + 1][y1] > 0 and MapTemp[x1][y1 + 1] > 0:
#TurnEntity(r\obj, 0, r\angle, 0) r = CreateRoom(zone, Constants.ROOM2C, x1 * 8, 0, y1 * 8, MapName[x1][y1])
#ElseIf MapTemp(x - 1, y)>0 And MapTemp(x, y - 1)>0 r.angle = 90
#r = CreateRoom(zone, ROOM2C, x * 8, 0, y * 8, MapName(x, y)) r.obj.rotation.y = deg_to_rad(r.angle)
#TurnEntity(r\obj, 0, 270, 0) elif MapTemp[x1 - 1][y1] > 0 and MapTemp[x1][y1 - 1] > 0:
#r\angle = 270 r = CreateRoom(zone, Constants.ROOM2C, x1 * 8, 0, y1 * 8, MapName[x1][y1])
#Else r.angle = 270
#r = CreateRoom(zone, ROOM2C, x * 8, 0, y * 8, MapName(x, y)) r.obj.rotation.y = deg_to_rad(r.angle)
#EndIf else:
#MapRoomID(ROOM2C)=MapRoomID(ROOM2C)+1 r = CreateRoom(zone, Constants.ROOM2C, x1 * 8, 0, y1 * 8, MapName[x1][y1])
#EndIf MapRoomID[Constants.ROOM2C] = MapRoomID[Constants.ROOM2C] + 1
#Case 3 3:
#If MapRoomID(ROOM3) < MaxRooms And MapName(x,y) = "" Then if MapRoomID[Constants.ROOM3] < MaxRooms and MapName[x1][y1] == "":
#If MapRoom(ROOM3, MapRoomID(ROOM3)) <> "" Then MapName(x, y) = MapRoom(ROOM3, MapRoomID(ROOM3)) if MapRoom[Constants.ROOM3][MapRoomID[Constants.ROOM3]] != "":
#EndIf MapName[x1][y1] = MapRoom[Constants.ROOM3][MapRoomID[Constants.ROOM3]]
#
#r = CreateRoom(zone, ROOM3, x * 8, 0, y * 8, MapName(x, y)) r = CreateRoom(zone, Constants.ROOM3, x1 * 8, 0, y1 * 8, MapName[x1][y1])
#If (Not MapTemp(x, y - 1)) Then if not MapTemp[x1][y1 - 1]:
#TurnEntity(r\obj, 0, 180, 0) r.angle = 180
#r\angle = 180 r.obj.rotation.y = deg_to_rad(r.angle)
#ElseIf (Not MapTemp(x - 1, y)) elif not MapTemp[x1 - 1][y1]:
#TurnEntity(r\obj, 0, 90, 0) r.angle = 90
#r\angle = 90 r.obj.rotation.y = deg_to_rad(r.angle)
#ElseIf (Not MapTemp(x + 1, y)) elif not MapTemp[x1 + 1][y1]:
#TurnEntity(r\obj, 0, -90, 0) r.angle = 270
#r\angle = 270 r.obj.rotation.y = deg_to_rad(r.angle)
#End If MapRoomID[Constants.ROOM3] = MapRoomID[Constants.ROOM3] + 1
#MapRoomID(ROOM3)=MapRoomID(ROOM3)+1 4:
#Case 4 if MapRoomID[Constants.ROOM4] < MaxRooms and MapName[x1][y1] == "":
#If MapRoomID(ROOM4) < MaxRooms And MapName(x,y) = "" Then if MapRoom[Constants.ROOM4][MapRoomID[Constants.ROOM4]] != "":
#If MapRoom(ROOM4, MapRoomID(ROOM4)) <> "" Then MapName(x, y) = MapRoom(ROOM4, MapRoomID(ROOM4)) MapName[x1][y1] = MapRoom[Constants.ROOM4][MapRoomID[Constants.ROOM4]]
#EndIf
# r = CreateRoom(zone, Constants.ROOM4, x1 * 8, 0, y1 * 8, MapName[x1][y1])
#r = CreateRoom(zone, ROOM4, x * 8, 0, y * 8, MapName(x, y)) MapRoomID[Constants.ROOM4] = MapRoomID[Constants.ROOM4] + 1
#MapRoomID(ROOM4)=MapRoomID(ROOM4)+1
#End Select r = CreateRoom(0, Constants.ROOM1, (MapWidth - 1) * 8, 500, 8, "gatea")
# MapRoomID[Constants.ROOM1] = MapRoomID[Constants.ROOM1] + 1
#EndIf
# r = CreateRoom(0, Constants.ROOM1, (MapWidth - 1) * 8, 0, (MapHeight - 1) * 8, "pocketdimension")
#Next MapRoomID[Constants.ROOM1] = MapRoomID[Constants.ROOM1] + 1
#Next
# if IntroEnabled:
#r = CreateRoom(0, ROOM1, (MapWidth-1) * 8, 500, 8, "gatea") r = CreateRoom(0, Constants.ROOM1, 8, 0, (MapHeight - 1) * 8, "173")
#MapRoomID(ROOM1)=MapRoomID(ROOM1)+1 MapRoomID[Constants.ROOM1] = MapRoomID[Constants.ROOM1] + 1
#
#r = CreateRoom(0, ROOM1, (MapWidth-1) * 8, 0, (MapHeight-1) * 8, "pocketdimension") r = CreateRoom(0, Constants.ROOM1, 8, 800, 0, "dimension1499")
#MapRoomID(ROOM1)=MapRoomID(ROOM1)+1 MapRoomID[Constants.ROOM1] = MapRoomID[Constants.ROOM1] + 1
#
#If IntroEnabled # TODO: No overlaps!
#r = CreateRoom(0, ROOM1, 8, 0, (MapHeight-1) * 8, "173")
#MapRoomID(ROOM1)=MapRoomID(ROOM1)+1
#EndIf
#
#r = CreateRoom(0, ROOM1, 8, 800, 0, "dimension1499")
#MapRoomID(ROOM1)=MapRoomID(ROOM1)+1
#
#For r.Rooms = Each Rooms #For r.Rooms = Each Rooms
#PreventRoomOverlap(r) #PreventRoomOverlap(r)
#Next #Next

82
src/LoadingScreen.gd
View file

@ -4,7 +4,8 @@ func InitLoadingScreen(file: String) -> LoadingScreen:
var loadingScreenIni = INI.Load(file) var loadingScreenIni = INI.Load(file)
var keys = loadingScreenIni.keys() var keys = loadingScreenIni.keys()
var randomScreen: Dictionary = loadingScreenIni[keys[randi_range(0, len(keys) - 1)]] var title = keys[randi_range(0, len(keys) - 1)]
var randomScreen: Dictionary = loadingScreenIni[title]
var loadingScreen = LoadingScreen.new() var loadingScreen = LoadingScreen.new()
loadingScreen.imgpath = randomScreen["image path"] loadingScreen.imgpath = randomScreen["image path"]
@ -17,6 +18,7 @@ func InitLoadingScreen(file: String) -> LoadingScreen:
loadingScreen.txt.push_back(randomScreen[str("text", i)]) loadingScreen.txt.push_back(randomScreen[str("text", i)])
loadingScreen.alignx = randomScreen["align x"] loadingScreen.alignx = randomScreen["align x"]
loadingScreen.aligny = randomScreen["align y"] loadingScreen.aligny = randomScreen["align y"]
loadingScreen.title = title
return loadingScreen return loadingScreen
@ -25,6 +27,54 @@ var background: TextureRect
var loadingImage: TextureRect var loadingImage: TextureRect
var bgImage: CompressedTexture2D var bgImage: CompressedTexture2D
const COUR_FONT = preload("res://GFX/font/cour/Courier New.ttf")
var textPos = Vector2(0, 0)
func DrawText(text: String, x: int, y: int, font, fontSize: float, shadowed: bool = false, center: bool = false):
textPos.x = x
textPos.y = y
if center:
var textSize = COUR_FONT.get_string_size(text, HORIZONTAL_ALIGNMENT_LEFT, -1, fontSize * Global.menuScale)
textPos.x -= textSize.x / 2
if shadowed:
draw_string(font, textPos + Vector2.ONE, text, HORIZONTAL_ALIGNMENT_LEFT, -1, fontSize * Global.menuScale, Color.BLACK)
draw_string(font, textPos, text, HORIZONTAL_ALIGNMENT_LEFT, -1, fontSize * Global.menuScale)
func generateTextRows(string = "", mw = 0):
var arrayIndex = 0;
var strings = [""];
var needToSplit = false;
var justSplit = false;
for char in string:
justSplit = false;
if needToSplit and char == " ":
needToSplit = false
justSplit = true
strings.push_back("")
arrayIndex += 1
if COUR_FONT.get_string_size(strings[arrayIndex], HORIZONTAL_ALIGNMENT_LEFT, -1).x > mw and !needToSplit:
needToSplit = true
if not justSplit:
strings[arrayIndex] += char
return strings
func renderTextRows(rows: Array, x: int, y: int):
for i in range(rows.size()):
var textSize = COUR_FONT.get_string_size(rows[i], HORIZONTAL_ALIGNMENT_LEFT, -1, 19 * Global.menuScale)
DrawText(rows[i], x, y + (textSize.y * i), COUR_FONT, 19, true, true)
var loadProgressIndex: int = 0
var loadingText: Array = []
var percent: int = 0
func LoadProgress(progress: int):
if progress > ((100 / loadingText.size()) * (loadProgressIndex + 1)):
loadProgressIndex += 1
percent = progress
queue_redraw()
func _ready() -> void: func _ready() -> void:
background = $Background background = $Background
loadingImage = $LoadingImage loadingImage = $LoadingImage
@ -37,8 +87,12 @@ func _ready() -> void:
background.texture = bgImage background.texture = bgImage
background.visible = true background.visible = true
#selectedLoadingScreen.img = ImageTexture.create_from_image(Utils.KeyBackground(Global.LoadTexture(str("Loadingscreens/", selectedLoadingScreen.imgpath)), Color(0, 0, 0, 1)))
selectedLoadingScreen.img = Global.LoadTexture(str("Loadingscreens/", selectedLoadingScreen.imgpath)) selectedLoadingScreen.img = Global.LoadTexture(str("Loadingscreens/", selectedLoadingScreen.imgpath))
loadingImage.texture = selectedLoadingScreen.img loadingImage.texture = selectedLoadingScreen.img
for text in selectedLoadingScreen.txt:
loadingText.push_back(generateTextRows(text, 400))
# Called every frame. 'delta' is the elapsed time since the previous frame. # Called every frame. 'delta' is the elapsed time since the previous frame.
func _process(delta: float) -> void: func _process(delta: float) -> void:
@ -64,3 +118,29 @@ func _process(delta: float) -> void:
loadingImage.position.y = size.y / 2 - loadingImage.size.y / 2 loadingImage.position.y = size.y / 2 - loadingImage.size.y / 2
"bottom": "bottom":
loadingImage.position.y = size.y - loadingImage.size.y loadingImage.position.y = size.y - loadingImage.size.y
@onready var binkMeterImg = Global.LoadTexture("GFX/BlinkMeter.jpg")
func _draw():
Global.menuScale = size.y / 1024.0
var width = 300
var height = 20
var x = size.x / 2 - width / 2
var y = size.y / 2 + 30 - 100
Utils.DrawLineRect(self, x, y, width + 4, height, Color.WHITE)
print(int((width - 2) * (percent / 100.0) / 10))
for i in range(1, int((width + 10) * (percent / 100.0) / 10)):
Utils.DrawImage(self, binkMeterImg, x + 3 + 10 * (i - 1), y + 3)
if selectedLoadingScreen.title == "CWM":
pass # TODO!
else:
DrawText(selectedLoadingScreen.title, size.x / 2 + 1, size.y / 2 + 80 + 1, COUR_FONT, 58, true, true)
renderTextRows(loadingText[loadProgressIndex], size.x / 2, size.y / 2 + 121)
DrawText(str("LOADING - ", percent, " %"), size.x / 2, size.y / 2 - 100, COUR_FONT, 19, true, true)
if percent == 100:
#If firstloop And SelectedLoadingScreen\title <> "CWM" Then PlaySound_Strict LoadTempSound(("SFX\Horror\Horror8.ogg"))
DrawText("PRESS ANY KEY TO CONTINUE", size.x / 2, size.y - 50, COUR_FONT, 19, false, true)

4
src/Player.gd
View file

@ -151,14 +151,14 @@ func _process(delta: float) -> void:
sprintBar.position.y = y sprintBar.position.y = y
var barAmount = int(((width - 2) * (BlinkTimer / (BLINKFREQ))) / 10) var barAmount = int(((width - 2) * (BlinkTimer / (BLINKFREQ))) / 10)
for i in int(((width - 2) * (BlinkTimer / (BLINKFREQ))) / 10): for i in range(int(((width - 2) * (BlinkTimer / (BLINKFREQ))) / 10)):
blinkBlocks.get_child(i).visible = true blinkBlocks.get_child(i).visible = true
for i in range(barAmount, 20): for i in range(barAmount, 20):
blinkBlocks.get_child(i).visible = false blinkBlocks.get_child(i).visible = false
barAmount = int(((width - 2) * (Stamina / 100.0)) / 10) barAmount = int(((width - 2) * (Stamina / 100.0)) / 10)
for i in int(((width - 2) * (Stamina / 100.0)) / 10): for i in range(int(((width - 2) * (Stamina / 100.0)) / 10)):
staminaBlocks.get_child(i).visible = true staminaBlocks.get_child(i).visible = true
for i in range(barAmount, 20): for i in range(barAmount, 20):

66
src/Utils.gd
View file

@ -25,6 +25,7 @@ static func KeyBackground(image, key: Color):
for x in imageRaw.get_width(): for x in imageRaw.get_width():
if imageRaw.get_pixel(x, y) == key: if imageRaw.get_pixel(x, y) == key:
imageRaw.set_pixel(x, y, Color.TRANSPARENT) imageRaw.set_pixel(x, y, Color.TRANSPARENT)
return imageRaw
static var cachedLookupPaths = Dictionary() static var cachedLookupPaths = Dictionary()
@ -64,7 +65,7 @@ static func Init2DArray(sizeX: int, sizeY: int, initValue: Variant = null) -> Ar
array.append(yArray) array.append(yArray)
for i1 in range(sizeY): for i1 in range(sizeY):
yArray.append(initValue) yArray.append(initValue)
return array return array
static func GenerateSeedNumber(seedv: String): static func GenerateSeedNumber(seedv: String):
@ -77,3 +78,66 @@ static func GenerateSeedNumber(seedv: String):
hashv = ((hashv << 5) - hashv) + chr hashv = ((hashv << 5) - hashv) + chr
hashv |= 0 hashv |= 0
return hashv return hashv
static var workingPos1 = Vector2()
static var workingPos2 = Vector2()
static func DrawLineRect(target: Control, x: int, y: int, width: int, height: int, color: Color):
workingPos1.x = x + 0.5
workingPos1.y = y + 0.5
workingPos2.x = x + width + 0.5
workingPos2.y = y + 0.5
target.draw_line(workingPos1, workingPos2, color, 1.0)
workingPos1.x = x + 0.5
workingPos1.y = y + height + 0.5
workingPos2.x = x + width + 0.5
workingPos2.y = y + height + 0.5
target.draw_line(workingPos1, workingPos2, color, 1.0)
workingPos1.x = x + 0.5
workingPos1.y = y + 0.5
workingPos2.x = x + 0.5
workingPos2.y = y + height + 0.5
target.draw_line(workingPos1, workingPos2, color, 1.0)
workingPos1.x = x + width + 0.5
workingPos1.y = y + 0.5
workingPos2.x = x + width + 0.5
workingPos2.y = y + height + 1.5
target.draw_line(workingPos1, workingPos2, color, 1.0)
static func DrawImage(target: Control, texture, x: int, y: int):
workingPos1.x = x
workingPos1.y = y
target.draw_texture(texture, workingPos1)
static func get_node_aabb(node : Node3D = null, ignore_top_level : bool = true, bounds_transform : Transform3D = Transform3D()) -> AABB:
var box : AABB
var transform : Transform3D
# we are going down the child chain, we want the aabb of each subsequent node to be on the same axis as the parent
if bounds_transform.is_equal_approx(Transform3D()):
transform = node.global_transform
else:
transform = bounds_transform
# no more nodes. return default aabb
if node == null:
return AABB(Vector3(-0.2, -0.2, -0.2), Vector3(0.4, 0.4, 0.4))
# makes sure the transform we get isn't distorted
var top_xform : Transform3D = transform.affine_inverse() * node.global_transform
# convert the node into visualinstance3D to access get_aabb() function.
var visual_result : VisualInstance3D = node as VisualInstance3D
if visual_result != null:
box = visual_result.get_aabb()
else:
box = AABB()
# xforms the transform with the box aabb for proper alignment I believe?
box = top_xform * box
# recursion
for i : int in node.get_child_count():
var child : Node3D = node.get_child(i) as Node3D
if child && !(ignore_top_level && child.top_level):
var child_box : AABB = get_node_aabb(child, ignore_top_level, transform)
box = box.merge(child_box)
return box

17
src/file_parsers/INI.gd
View file

@ -18,7 +18,22 @@ static func Load(file: String, ignoreLoose:bool = true):
currentSection = sections.get_or_add(sectionName, Dictionary()) currentSection = sections.get_or_add(sectionName, Dictionary())
else: else:
if not ignoreLoose or (ignoreLoose and sectionName != "loose"): if not ignoreLoose or (ignoreLoose and sectionName != "loose"):
var segments = line.replace(" = ", "=").split("=") var segments = line.replace(" = ", "=").replace("= ", "=").replace(" =", "=").split("=")
currentSection.get_or_add(segments[0], segments[1]) currentSection.get_or_add(segments[0], segments[1])
return sections return sections
static func GetInt(dict: Dictionary, name: String) -> int:
if dict.has(name):
return dict[name].to_int()
return 0
static func GetBool(dict: Dictionary, name: String) -> bool:
if dict.has(name):
return dict[name].to_lower() == "true"
return false
static func GetString(dict: Dictionary, name: String) -> String:
if dict.has(name):
return dict[name]
return ""

108
src/file_parsers/RMesh.gd
View file

@ -4,8 +4,6 @@ static func ReadString(reader:BufferStuffReader):
var length = reader.readInt() var length = reader.readInt()
return reader.readBuffer(length).get_string_from_ascii() return reader.readBuffer(length).get_string_from_ascii()
const WORLD_SCALE = 0.010
static func StripFilename(file: String): static func StripFilename(file: String):
var mi = "" var mi = ""
var lastSlash = 0 var lastSlash = 0
@ -21,7 +19,7 @@ static var EMPTY_TEXTURE = Texture2D.new()
static var RMESH_LOAD_COUNT = 0 static var RMESH_LOAD_COUNT = 0
static func LoadRMesh(parentNode: Node3D, file: String): static func LoadRMesh(file: String, rt: RoomTemplate):
var correctedPath = file.replace("\\", "/") var correctedPath = file.replace("\\", "/")
var fileName = correctedPath.split("/")[-1] var fileName = correctedPath.split("/")[-1]
@ -36,9 +34,8 @@ static func LoadRMesh(parentNode: Node3D, file: String):
return return
var scene = Node3D.new() var scene = Node3D.new()
scene.name = str(fileName, "_", RMESH_LOAD_COUNT) scene.name = str(fileName, "_", rt.Name, "_", RMESH_LOAD_COUNT)
RMESH_LOAD_COUNT += 1 RMESH_LOAD_COUNT += 1
parentNode.add_child(scene)
var count: int = 0 var count: int = 0
var count2: int = 0 var count2: int = 0
@ -172,9 +169,9 @@ static func LoadRMesh(parentNode: Node3D, file: String):
for j2 in range(count2): for j2 in range(count2):
# world coords # world coords
x = -reader.readFloat() * WORLD_SCALE x = -reader.readFloat() * Constants.RoomScale
y = reader.readFloat() * WORLD_SCALE y = reader.readFloat() * Constants.RoomScale
z = reader.readFloat() * WORLD_SCALE z = reader.readFloat() * Constants.RoomScale
#vertex = AddVertex(surf,x,y,z) #vertex = AddVertex(surf,x,y,z)
vertices.push_back(Vector3(x, y, z)) vertices.push_back(Vector3(x, y, z))
@ -283,9 +280,9 @@ static func LoadRMesh(parentNode: Node3D, file: String):
count2 = reader.readInt() # vertices count2 = reader.readInt() # vertices
for j2 in range(count2): for j2 in range(count2):
# world coords # world coords
x = -reader.readFloat() * WORLD_SCALE x = -reader.readFloat() * Constants.RoomScale
y = reader.readFloat() * WORLD_SCALE y = reader.readFloat() * Constants.RoomScale
z = reader.readFloat() * WORLD_SCALE z = reader.readFloat() * Constants.RoomScale
verts.push_back(Vector3(x, y, z)) verts.push_back(Vector3(x, y, z))
count2 = reader.readInt() # polys count2 = reader.readInt() # polys
@ -327,15 +324,13 @@ static func LoadRMesh(parentNode: Node3D, file: String):
var tbVerts = PackedVector3Array() var tbVerts = PackedVector3Array()
var tbIndexes = PackedInt32Array() var tbIndexes = PackedInt32Array()
#rt\TempTriggerbox[tb] = CreateMesh(rt\obj)
count = reader.readInt() count = reader.readInt()
for i1 in range(count): for i1 in range(count):
#surf=CreateSurface(rt\TempTriggerbox[tb])
count2 = reader.readInt() count2 = reader.readInt()
for j2 in range(count2): for j2 in range(count2):
x = -reader.readFloat() * WORLD_SCALE x = -reader.readFloat() * Constants.RoomScale
y = reader.readFloat() * WORLD_SCALE y = reader.readFloat() * Constants.RoomScale
z = reader.readFloat() * WORLD_SCALE z = reader.readFloat() * Constants.RoomScale
tbVerts.push_back(Vector3(x, y, z)) tbVerts.push_back(Vector3(x, y, z))
#vertex=AddVertex(surf,x,y,z) #vertex=AddVertex(surf,x,y,z)
@ -372,16 +367,17 @@ static func LoadRMesh(parentNode: Node3D, file: String):
#meshInstance.visible = false #meshInstance.visible = false
scene.add_child(meshInstance) scene.add_child(meshInstance)
meshInstance.name = ReadString(reader) meshInstance.name = ReadString(reader)
#rt\TempTriggerboxName[tb] = ReadString(f) rt.TempTriggerbox[tb] = meshInstance
rt.TempTriggerboxName[tb] = ReadString(reader)
count = reader.readInt() # point entities count = reader.readInt() # point entities
for i1 in range(count): for i1 in range(count):
temp1s = ReadString(reader) temp1s = ReadString(reader)
#print(str("POINT ENTITY: ", temp1s)) #print(str("POINT ENTITY: ", temp1s))
if temp1s == "screen": if temp1s == "screen":
temp1 = -reader.readFloat() * WORLD_SCALE temp1 = -reader.readFloat() * Constants.RoomScale
temp2 = reader.readFloat() * WORLD_SCALE temp2 = reader.readFloat() * Constants.RoomScale
temp3 = reader.readFloat() * WORLD_SCALE temp3 = reader.readFloat() * Constants.RoomScale
temp2s = ReadString(reader) temp2s = ReadString(reader)
if temp1 != 0 or temp2 != 0 or temp3 != 0: if temp1 != 0 or temp2 != 0 or temp3 != 0:
@ -390,11 +386,11 @@ static func LoadRMesh(parentNode: Node3D, file: String):
ts.y = temp2 ts.y = temp2
ts.z = temp3 ts.z = temp3
ts.imgpath = temp2s ts.imgpath = temp2s
#ts\roomtemplate = rt ts.roomtemplate = rt
elif temp1s == "waypoint": elif temp1s == "waypoint":
temp1 = -reader.readFloat() * WORLD_SCALE temp1 = -reader.readFloat() * Constants.RoomScale
temp2 = reader.readFloat() * WORLD_SCALE temp2 = reader.readFloat() * Constants.RoomScale
temp3 = reader.readFloat() * WORLD_SCALE temp3 = reader.readFloat() * Constants.RoomScale
var marker = Marker3D.new() var marker = Marker3D.new()
marker.position = Vector3(temp1, temp2, temp3) marker.position = Vector3(temp1, temp2, temp3)
@ -407,9 +403,9 @@ static func LoadRMesh(parentNode: Node3D, file: String):
#w\z = temp3 #w\z = temp3
# #
elif temp1s == "light": elif temp1s == "light":
temp1 = -reader.readFloat() * WORLD_SCALE temp1 = -reader.readFloat() * Constants.RoomScale
temp2 = reader.readFloat() * WORLD_SCALE temp2 = reader.readFloat() * Constants.RoomScale
temp3 = reader.readFloat() * WORLD_SCALE temp3 = reader.readFloat() * Constants.RoomScale
if temp1 != 0 or temp2 != 0 or temp3 != 0: if temp1 != 0 or temp2 != 0 or temp3 != 0:
var range = reader.readFloat() / 2000.0 var range = reader.readFloat() / 2000.0
@ -431,9 +427,9 @@ static func LoadRMesh(parentNode: Node3D, file: String):
ReadString(reader) ReadString(reader)
reader.readFloat() reader.readFloat()
elif temp1s == "spotlight": elif temp1s == "spotlight":
temp1 = -reader.readFloat() * WORLD_SCALE temp1 = -reader.readFloat() * Constants.RoomScale
temp2 = reader.readFloat() * WORLD_SCALE temp2 = reader.readFloat() * Constants.RoomScale
temp3 = reader.readFloat() * WORLD_SCALE temp3 = reader.readFloat() * Constants.RoomScale
if temp1 != 0 or temp2 != 0 or temp3 != 0: if temp1 != 0 or temp2 != 0 or temp3 != 0:
var range = reader.readFloat() / 2000.0 var range = reader.readFloat() / 2000.0
var lcolor = ReadString(reader).split(" ") var lcolor = ReadString(reader).split(" ")
@ -468,28 +464,23 @@ static func LoadRMesh(parentNode: Node3D, file: String):
reader.readInt() reader.readInt()
reader.readFloat() reader.readFloat()
#temp1i=0 temp1i=0
#For j = 0 To MaxRoomEmitters-1 for j1 in range(Constants.MaxRoomEmitters - 1):
#If rt\TempSoundEmitter[j]=0 Then if rt.TempSoundEmitter[j1] == null:
#rt\TempSoundEmitterX[j]=ReadFloat(f)*RoomScale rt.TempSoundEmitterX[j1] = reader.readFloat() * Constants.RoomScale
#rt\TempSoundEmitterY[j]=ReadFloat(f)*RoomScale rt.TempSoundEmitterY[j1] = reader.readFloat() * Constants.RoomScale
#rt\TempSoundEmitterZ[j]=ReadFloat(f)*RoomScale rt.TempSoundEmitterZ[j1] = reader.readFloat() * Constants.RoomScale
#rt\TempSoundEmitter[j]=ReadInt(f) rt.TempSoundEmitter[j1] = reader.readInt()
#
#rt\TempSoundEmitterRange[j]=ReadFloat(f) rt.TempSoundEmitterRange[j1] = reader.readFloat()
#temp1i=1 temp1i=1
#Exit break
#EndIf if temp1i == 0:
#Next reader.readFloat()
# reader.readFloat()
#If temp1i=0 Then reader.readFloat()
#ReadFloat(f) reader.readInt()
#ReadFloat(f) reader.readFloat()
#ReadFloat(f)
#ReadInt(f)
#ReadFloat(f)
#EndIf
#
elif temp1s == "playerstart": elif temp1s == "playerstart":
temp1 = -reader.readFloat() temp1 = -reader.readFloat()
temp2 = reader.readFloat() temp2 = reader.readFloat()
@ -509,9 +500,9 @@ static func LoadRMesh(parentNode: Node3D, file: String):
var model = X.LoadModel(str("GFX/Map/Props/", modelPath)) var model = X.LoadModel(str("GFX/Map/Props/", modelPath))
scene.add_child(model) scene.add_child(model)
# #
temp1 = -reader.readFloat() * WORLD_SCALE temp1 = -reader.readFloat() * Constants.RoomScale
temp2 = reader.readFloat() * WORLD_SCALE temp2 = reader.readFloat() * Constants.RoomScale
temp3 = reader.readFloat() * WORLD_SCALE temp3 = reader.readFloat() * Constants.RoomScale
model.position = Vector3(temp1, temp2, temp3) model.position = Vector3(temp1, temp2, temp3)
#PositionEntity model,temp1,temp2,temp3 #PositionEntity model,temp1,temp2,temp3
@ -523,9 +514,9 @@ static func LoadRMesh(parentNode: Node3D, file: String):
model.rotation = Vector3(deg_to_rad(temp1), deg_to_rad(temp2), deg_to_rad(temp3)) model.rotation = Vector3(deg_to_rad(temp1), deg_to_rad(temp2), deg_to_rad(temp3))
#RotateEntity model,temp1,temp2,temp3 #RotateEntity model,temp1,temp2,temp3
# #
temp1 = reader.readFloat() * WORLD_SCALE temp1 = reader.readFloat() * Constants.RoomScale
temp2 = reader.readFloat() * WORLD_SCALE temp2 = reader.readFloat() * Constants.RoomScale
temp3 = reader.readFloat() * WORLD_SCALE temp3 = reader.readFloat() * Constants.RoomScale
model.scale = Vector3(temp1, temp2, temp3) model.scale = Vector3(temp1, temp2, temp3)
#ScaleEntity model,temp1,temp2,temp3 #ScaleEntity model,temp1,temp2,temp3
@ -577,3 +568,4 @@ static func LoadRMesh(parentNode: Node3D, file: String):
# #
#CatchErrors("LoadRMesh") #CatchErrors("LoadRMesh")
#Return obj% #Return obj%
return scene

7
src/objects/Grid.gd Normal file
View file

@ -0,0 +1,7 @@
class_name Grid
var grid: Array = Utils.Init1DArray(Constants.gridsz * Constants.gridsz)
var angles: Array = Utils.Init1DArray(Constants.gridsz * Constants.gridsz)
var Meshes: Array = Utils.Init1DArray(7)
var Entities: Array = Utils.Init1DArray(Constants.gridsz * Constants.gridsz)
var waypoints: Array = Utils.Init1DArray(Constants.gridsz * Constants.gridsz) # Type: WayPoint

2
src/objects/LoadingScreen.gd
View file

@ -1,7 +1,7 @@
class_name LoadingScreen # HAM class_name LoadingScreen # HAM
var imgpath = "" var imgpath = ""
var img: CompressedTexture2D var img: Texture2D
var ID = 0 var ID = 0
var title = "" var title = ""
var alignx = 0 var alignx = 0

66
src/objects/Room.gd Normal file
View file

@ -0,0 +1,66 @@
class_name Room
var zone: int
var found
var obj: Node3D
var x: float
var y: float
var z: float
var angle: float
var RoomTemplate: RoomTemplate
var dist: float
var SoundCHN: AudioStreamPlayer
#var dp.DrawPortal, fr.Forest
var SoundEmitter = Utils.Init1DArray(Constants.MaxRoomEmitters)
var SoundEmitterObj = Utils.Init1DArray(Constants.MaxRoomEmitters)
var SoundEmitterRange = Utils.Init1DArray(Constants.MaxRoomEmitters)
var SoundEmitterCHN = Utils.Init1DArray(Constants.MaxRoomEmitters)
var Lights: Array = Utils.Init1DArray(Constants.MaxRoomLights)
var LightIntensity: Array = Utils.Init1DArray(Constants.MaxRoomLights)
var LightSprites: Array = Utils.Init1DArray(Constants.MaxRoomLights)
var Objects: Array = Utils.Init1DArray(Constants.MaxRoomObjects)
var Levers: Array = Utils.Init1DArray(11)
var RoomDoors: Array = Utils.Init1DArray(7) # Type: Doors
var NPC: Array = Utils.Init1DArray(12) # Type: NPC
var grid: Grid # Type: Grid
var Adjacent: Array = Utils.Init1DArray(4) # Type: Room
var AdjDoor: Array = Utils.Init1DArray(4) # Type: Door
var NonFreeAble = Utils.Init1DArray(10)
var Textures = Utils.Init1DArray(10)
var MaxLights = 0
var LightSpriteHidden: Array = Utils.Init1DArray(Constants.MaxRoomLights)
var LightSpritesPivot: Array = Utils.Init1DArray(Constants.MaxRoomLights)
var LightSprites2: Array = Utils.Init1DArray(Constants.MaxRoomLights)
var LightHidden: Array = Utils.Init1DArray(Constants.MaxRoomLights)
var LightFlicker: Array = Utils.Init1DArray(Constants.MaxRoomLights)
var AlarmRotor: Array = Utils.Init1DArray(1)
var AlarmRotorLight: Array = Utils.Init1DArray(1)
var TriggerboxAmount: int
var Triggerbox: Array = Utils.Init1DArray(128) # Type: String
var TriggerboxName: Array = Utils.Init1DArray(128) # Type: String
var MaxWayPointY: float
var LightR: Array = Utils.Init1DArray(Constants.MaxRoomLights)
var LightG: Array = Utils.Init1DArray(Constants.MaxRoomLights)
var LightB: Array = Utils.Init1DArray(Constants.MaxRoomLights)
var LightCone: Array = Utils.Init1DArray(Constants.MaxRoomLights)
var LightConeSpark: Array = Utils.Init1DArray(Constants.MaxRoomLights)
var LightConeSparkTimer: Array = Utils.Init1DArray(Constants.MaxRoomLights)
var MinX: float
var MinY: float
var MinZ: float
var MaxX: float
var MaxY: float
var MaxZ: float

36
src/objects/RoomTemplate.gd Normal file
View file

@ -0,0 +1,36 @@
class_name RoomTemplate
var obj: Node3D
var id: int
var objPath: String
var zone = Utils.Init1DArray(5, 0)
#Field ambience%
var TempSoundEmitter = Utils.Init1DArray(Constants.MaxRoomEmitters)
var TempSoundEmitterX = Utils.Init1DArray(Constants.MaxRoomEmitters)
var TempSoundEmitterY = Utils.Init1DArray(Constants.MaxRoomEmitters)
var TempSoundEmitterZ = Utils.Init1DArray(Constants.MaxRoomEmitters)
var TempSoundEmitterRange = Utils.Init1DArray(Constants.MaxRoomEmitters)
var Shape: int
var Name: String
var Commonness: float
var Large: bool
var DisableDecals: bool
var TempTriggerboxAmount: int
var TempTriggerbox = Utils.Init1DArray(128)
var TempTriggerboxName = Utils.Init1DArray(128)
var UseLightCones: bool
var DisableOverlapCheck: bool = true
var MinX: int
var MinY: int
var MinZ: int
var MaxX: int
var MaxY: int
var MaxZ: int

1
src/TempScreen.gd → src/objects/TempScreen.gd
View file

@ -4,3 +4,4 @@ var imgpath: String
var x: float var x: float
var y: float var y: float
var z: float var z: float
var roomtemplate: RoomTemplate