Relintai/world_generator
1
0
Fork 0
mirror of https://github.com/Relintai/world_generator.git synced 2024-11-12 10:15:07 +01:00
Code Issues Packages Projects Releases Wiki Activity

Added in the bindings, and variables that I planned.

Browse Source
This commit is contained in:
Relintai 2019-09-24 15:08:43 +02:00
parent 16ae08568a
commit e60f95da9a
20 changed files with 676 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
SCsub
View File

@ -1,16 +1,17 @@
Import('env')
env.add_source_files(env.modules_sources,"register_types.cpp")
env.add_source_files(env.modules_sources,"main/dungeon_room.cpp")
env.add_source_files(env.modules_sources,"main/dungeon.cpp")
env.add_source_files(env.modules_sources,"main/biome.cpp")
env.add_source_files(env.modules_sources,"main/planet.cpp")
env.add_source_files(env.modules_sources,"data/dungeon_room_data.cpp")
env.add_source_files(env.modules_sources,"data/dungeon_data.cpp")
env.add_source_files(env.modules_sources,"data/biome_data.cpp")
env.add_source_files(env.modules_sources,"data/planet_data.cpp")
env.add_source_files(env.modules_sources,"world_generator.cpp")
env.add_source_files(env.modules_sources,"register_types.cpp")
env.add_source_files(env.modules_sources,"main/dungeon_room.cpp")
env.add_source_files(env.modules_sources,"main/dungeon.cpp")
env.add_source_files(env.modules_sources,"main/biome.cpp")
env.add_source_files(env.modules_sources,"main/planet.cpp")
env.add_source_files(env.modules_sources,"data/dungeon_room_data.cpp")
env.add_source_files(env.modules_sources,"data/dungeon_data.cpp")
env.add_source_files(env.modules_sources,"data/biome_data.cpp")
env.add_source_files(env.modules_sources,"data/planet_data.cpp")
env.add_source_files(env.modules_sources,"data/prop_data.cpp")
env.add_source_files(env.modules_sources,"world_generator.cpp")

131
data/biome_data.cpp
View File

@ -1,5 +1,101 @@
#include "biome_data.h"
Vector2 BiomeData::get_humidity_range() {
return _humidity_range;
}
void BiomeData::set_humidity_range(Vector2 range) {
_humidity_range = range;
}
Vector2 BiomeData::get_temperature_range() {
return _temperature_range;
}
void BiomeData::set_temperature_range(Vector2 range) {
_temperature_range = range;
}
//// DungeonData ////
Ref<DungeonData> BiomeData::get_dungeon_data(const int index) const {
ERR_FAIL_INDEX_V(index, _dungeon_datas.size(), Ref<DungeonData>());
return _dungeon_datas.get(index);
}
void BiomeData::set_dungeon_data(const int index, const Ref<DungeonData> dungeon_data) {
ERR_FAIL_INDEX(index, _dungeon_datas.size());
_dungeon_datas.set(index, dungeon_data);
}
void BiomeData::add_dungeon_data(const Ref<DungeonData> dungeon_data) {
_dungeon_datas.push_back(dungeon_data);
}
void BiomeData::remove_dungeon_data(const int index) {
ERR_FAIL_INDEX(index, _dungeon_datas.size());
_dungeon_datas.remove(index);
}
int BiomeData::get_dungeon_data_count() const {
return _dungeon_datas.size();
}
Vector<Variant> BiomeData::get_dungeon_datas() {
Vector<Variant> r;
for (int i = 0; i < _dungeon_datas.size(); i++) {
r.push_back(_dungeon_datas[i].get_ref_ptr());
}
return r;
}
void BiomeData::set_dungeon_datas(const Vector<Variant> &dungeon_datas) {
_dungeon_datas.clear();
for (int i = 0; i < dungeon_datas.size(); i++) {
Ref<DungeonData> dungeon_data = Ref<DungeonData>(dungeon_datas[i]);
_dungeon_datas.push_back(dungeon_data);
}
}
//// PROP DATA ////
Ref<PropData> BiomeData::get_prop_data(const int index) const {
ERR_FAIL_INDEX_V(index, _prop_datas.size(), Ref<PropData>());
return _prop_datas.get(index);
}
void BiomeData::set_prop_data(const int index, const Ref<PropData> prop_data) {
ERR_FAIL_INDEX(index, _prop_datas.size());
_prop_datas.set(index, prop_data);
}
void BiomeData::add_prop_data(const Ref<PropData> prop_data) {
_prop_datas.push_back(prop_data);
}
void BiomeData::remove_prop_data(const int index) {
ERR_FAIL_INDEX(index, _prop_datas.size());
_prop_datas.remove(index);
}
int BiomeData::get_prop_data_count() const {
return _prop_datas.size();
}
Vector<Variant> BiomeData::get_prop_datas() {
Vector<Variant> r;
for (int i = 0; i < _prop_datas.size(); i++) {
r.push_back(_prop_datas[i].get_ref_ptr());
}
return r;
}
void BiomeData::set_prop_datas(const Vector<Variant> &prop_datas) {
_prop_datas.clear();
for (int i = 0; i < prop_datas.size(); i++) {
Ref<PropData> prop_data = Ref<PropData>(prop_datas[i]);
_prop_datas.push_back(prop_data);
}
}
Ref<Biome> BiomeData::setup_biome(int seed) {
if (has_method("_setup_biome")) {
return call("_setup_biome", seed);
@ -12,11 +108,44 @@ BiomeData::BiomeData() {
}
BiomeData::~BiomeData() {
_dungeon_datas.clear();
_prop_datas.clear();
}
void BiomeData::_bind_methods() {
BIND_VMETHOD(MethodInfo(PropertyInfo(Variant::OBJECT, "room", PROPERTY_HINT_RESOURCE_TYPE, "Biome"), "_setup_biome", PropertyInfo(Variant::INT, "seed")));
ClassDB::bind_method(D_METHOD("setup_biome", "seed"), &BiomeData::setup_biome);
ClassDB::bind_method(D_METHOD("get_humidity_range"), &BiomeData::get_humidity_range);
ClassDB::bind_method(D_METHOD("set_humidity_range", "value"), &BiomeData::set_humidity_range);
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "humidity_range"), "set_humidity_range", "get_humidity_range");
ClassDB::bind_method(D_METHOD("get_temperature_range"), &BiomeData::get_temperature_range);
ClassDB::bind_method(D_METHOD("set_temperature_range", "value"), &BiomeData::set_temperature_range);
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "temperature_range"), "set_temperature_range", "get_temperature_range");
//DungeonDatas
ClassDB::bind_method(D_METHOD("get_dungeon_data", "index"), &BiomeData::get_dungeon_data);
ClassDB::bind_method(D_METHOD("set_dungeon_data", "index", "data"), &BiomeData::set_dungeon_data);
ClassDB::bind_method(D_METHOD("add_dungeon_data", "dungeon_data"), &BiomeData::add_dungeon_data);
ClassDB::bind_method(D_METHOD("remove_dungeon_data", "index"), &BiomeData::remove_dungeon_data);
ClassDB::bind_method(D_METHOD("get_dungeon_data_count"), &BiomeData::get_dungeon_data_count);
ClassDB::bind_method(D_METHOD("get_dungeon_datas"), &BiomeData::get_dungeon_datas);
ClassDB::bind_method(D_METHOD("set_dungeon_datas", "dungeon_datas"), &BiomeData::set_dungeon_datas);
ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "dungeon_datas", PROPERTY_HINT_NONE, "17/17:DungeonData", PROPERTY_USAGE_DEFAULT, "DungeonData"), "set_dungeon_datas", "get_dungeon_datas");
//PropData
ClassDB::bind_method(D_METHOD("get_prop_data", "index"), &BiomeData::get_prop_data);
ClassDB::bind_method(D_METHOD("set_prop_data", "index", "data"), &BiomeData::set_prop_data);
ClassDB::bind_method(D_METHOD("add_prop_data", "prop_data"), &BiomeData::add_prop_data);
ClassDB::bind_method(D_METHOD("remove_prop_data", "index"), &BiomeData::remove_prop_data);
ClassDB::bind_method(D_METHOD("get_prop_data_count"), &BiomeData::get_prop_data_count);
ClassDB::bind_method(D_METHOD("get_prop_datas"), &BiomeData::get_prop_datas);
ClassDB::bind_method(D_METHOD("set_prop_datas", "prop_datas"), &BiomeData::set_prop_datas);
ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "prop_datas", PROPERTY_HINT_NONE, "17/17:PropData", PROPERTY_USAGE_DEFAULT, "PropData"), "set_prop_datas", "get_prop_datas");
}

43
data/biome_data.h
View File

@ -1,14 +1,45 @@
#ifndef BIOME_DATA_H
#define BIOME_DATA_H
#ifndef dungeon_data_H
#define dungeon_data_H
#include "core/resource.h"
#include "core/vector.h"
#include "core/math/vector2.h"
#include "../main/biome.h"
#include "dungeon_data.h"
#include "prop_data.h"
class BiomeData : public Resource {
GDCLASS(BiomeData, Resource);
public:
Vector2 get_humidity_range();
void set_humidity_range(Vector2 range);
Vector2 get_temperature_range();
void set_temperature_range(Vector2 range);
//DungeonData
Ref<DungeonData> get_dungeon_data(const int index) const;
void set_dungeon_data(const int index, const Ref<DungeonData> dungeon_data);
void add_dungeon_data(const Ref<DungeonData> dungeon_data);
void remove_dungeon_data(const int index);
int get_dungeon_data_count() const;
Vector<Variant> get_dungeon_datas();
void set_dungeon_datas(const Vector<Variant> &dungeon_datas);
//PropData
Ref<PropData> get_prop_data(const int index) const;
void set_prop_data(const int index, const Ref<PropData> prop_data);
void add_prop_data(const Ref<PropData> prop_data);
void remove_prop_data(const int index);
int get_prop_data_count() const;
Vector<Variant> get_prop_datas();
void set_prop_datas(const Vector<Variant> &prop_datas);
Ref<Biome> setup_biome(int seed);
@ -20,10 +51,10 @@ protected:
private:
//Vector2 _humidity_range;
//Vector2 _temperature_range;
//Vector<DungeonData> _dungeon_datas;
//Vector<Ref<VoxelmanProp> > _props;
Vector2 _humidity_range;
Vector2 _temperature_range;
Vector<Ref<DungeonData> > _dungeon_datas;
Vector<Ref<PropData> > _prop_datas;
};
#endif

50
data/dungeon_data.cpp
View File

@ -1,5 +1,44 @@
#include "dungeon_data.h"
Ref<DungeonRoomData> DungeonData::get_dungeon_room_data(const int index) const {
ERR_FAIL_INDEX_V(index, _dungeon_room_datas.size(), Ref<DungeonRoomData>());
return _dungeon_room_datas.get(index);
}
void DungeonData::set_dungeon_room_data(const int index, const Ref<DungeonRoomData> dungeon_room_data) {
ERR_FAIL_INDEX(index, _dungeon_room_datas.size());
_dungeon_room_datas.set(index, dungeon_room_data);
}
void DungeonData::add_dungeon_room_data(const Ref<DungeonRoomData> dungeon_room_data) {
_dungeon_room_datas.push_back(dungeon_room_data);
}
void DungeonData::remove_dungeon_room_data(const int index) {
ERR_FAIL_INDEX(index, _dungeon_room_datas.size());
_dungeon_room_datas.remove(index);
}
int DungeonData::get_dungeon_room_data_count() const {
return _dungeon_room_datas.size();
}
Vector<Variant> DungeonData::get_dungeon_room_datas() {
Vector<Variant> r;
for (int i = 0; i < _dungeon_room_datas.size(); i++) {
r.push_back(_dungeon_room_datas[i].get_ref_ptr());
}
return r;
}
void DungeonData::set_dungeon_room_datas(const Vector<Variant> &dungeon_room_datas) {
_dungeon_room_datas.clear();
for (int i = 0; i < dungeon_room_datas.size(); i++) {
Ref<DungeonRoomData> dungeon_room_data = Ref<DungeonRoomData>(dungeon_room_datas[i]);
_dungeon_room_datas.push_back(dungeon_room_data);
}
}
Ref<Dungeon> DungeonData::setup_dungeon(int seed) {
if (has_method("_setup_dungeon")) {
return call("_setup_dungeon", seed);
@ -19,4 +58,15 @@ void DungeonData::_bind_methods() {
BIND_VMETHOD(MethodInfo(PropertyInfo(Variant::OBJECT, "room", PROPERTY_HINT_RESOURCE_TYPE, "Dungeon"), "_setup_dungeon", PropertyInfo(Variant::INT, "seed")));
ClassDB::bind_method(D_METHOD("setup_dungeon", "seed"), &DungeonData::setup_dungeon);
ClassDB::bind_method(D_METHOD("get_dungeon_room_data", "index"), &DungeonData::get_dungeon_room_data);
ClassDB::bind_method(D_METHOD("set_dungeon_room_data", "index", "data"), &DungeonData::set_dungeon_room_data);
ClassDB::bind_method(D_METHOD("add_dungeon_room_data", "dungeon_room_data"), &DungeonData::add_dungeon_room_data);
ClassDB::bind_method(D_METHOD("remove_dungeon_room_data", "index"), &DungeonData::remove_dungeon_room_data);
ClassDB::bind_method(D_METHOD("get_dungeon_room_data_count"), &DungeonData::get_dungeon_room_data_count);
ClassDB::bind_method(D_METHOD("get_dungeon_room_datas"), &DungeonData::get_dungeon_room_datas);
ClassDB::bind_method(D_METHOD("set_dungeon_room_datas", "dungeon_room_datas"), &DungeonData::set_dungeon_room_datas);
ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "dungeon_room_datas", PROPERTY_HINT_NONE, "17/17:DungeonRoomData", PROPERTY_USAGE_DEFAULT, "DungeonRoomData"), "set_dungeon_room_datas", "get_dungeon_room_datas");
}

14
data/dungeon_data.h
View File

@ -2,13 +2,25 @@
#define DUNGEON_DATA_H
#include "core/resource.h"
#include "core/vector.h"
#include "../main/dungeon.h"
#include "dungeon_room_data.h"
class DungeonData : public Resource {
GDCLASS(DungeonData, Resource);
public:
Ref<DungeonRoomData> get_dungeon_room_data(const int index) const;
void set_dungeon_room_data(const int index, const Ref<DungeonRoomData> dungeon_room_data);
void add_dungeon_room_data(const Ref<DungeonRoomData> dungeon_room_data);
void remove_dungeon_room_data(const int index);
int get_dungeon_room_data_count() const;
Vector<Variant> get_dungeon_room_datas();
void set_dungeon_room_datas(const Vector<Variant> &dungeon_room_datas);
Ref<Dungeon> setup_dungeon(int seed);
DungeonData();
@ -18,7 +30,7 @@ protected:
static void _bind_methods();
private:
//Vector<Ref<DungeonRoomData> > _rooms;
Vector<Ref<DungeonRoomData> > _dungeon_room_datas;
};
#endif

50
data/dungeon_room_data.cpp
View File

@ -1,5 +1,44 @@
#include "dungeon_room_data.h"
Ref<PropData> DungeonRoomData::get_prop_data(const int index) const {
ERR_FAIL_INDEX_V(index, _prop_datas.size(), Ref<PropData>());
return _prop_datas.get(index);
}
void DungeonRoomData::set_prop_data(const int index, const Ref<PropData> prop_data) {
ERR_FAIL_INDEX(index, _prop_datas.size());
_prop_datas.set(index, prop_data);
}
void DungeonRoomData::add_prop_data(const Ref<PropData> prop_data) {
_prop_datas.push_back(prop_data);
}
void DungeonRoomData::remove_prop_data(const int index) {
ERR_FAIL_INDEX(index, _prop_datas.size());
_prop_datas.remove(index);
}
int DungeonRoomData::get_prop_data_count() const {
return _prop_datas.size();
}
Vector<Variant> DungeonRoomData::get_prop_datas() {
Vector<Variant> r;
for (int i = 0; i < _prop_datas.size(); i++) {
r.push_back(_prop_datas[i].get_ref_ptr());
}
return r;
}
void DungeonRoomData::set_prop_datas(const Vector<Variant> &prop_datas) {
_prop_datas.clear();
for (int i = 0; i < prop_datas.size(); i++) {
Ref<PropData> prop_data = Ref<PropData>(prop_datas[i]);
_prop_datas.push_back(prop_data);
}
}
Ref<DungeonRoom> DungeonRoomData::setup_room(int seed) {
if (has_method("_setup_room")) {
return call("_setup_room", seed);
@ -19,4 +58,15 @@ void DungeonRoomData::_bind_methods() {
BIND_VMETHOD(MethodInfo(PropertyInfo(Variant::OBJECT, "room", PROPERTY_HINT_RESOURCE_TYPE, "DungeonRoom"), "_setup_room", PropertyInfo(Variant::INT, "seed")));
ClassDB::bind_method(D_METHOD("setup_room", "seed"), &DungeonRoomData::setup_room);
ClassDB::bind_method(D_METHOD("get_prop_data", "index"), &DungeonRoomData::get_prop_data);
ClassDB::bind_method(D_METHOD("set_prop_data", "index", "data"), &DungeonRoomData::set_prop_data);
ClassDB::bind_method(D_METHOD("add_prop_data", "prop_data"), &DungeonRoomData::add_prop_data);
ClassDB::bind_method(D_METHOD("remove_prop_data", "index"), &DungeonRoomData::remove_prop_data);
ClassDB::bind_method(D_METHOD("get_prop_data_count"), &DungeonRoomData::get_prop_data_count);
ClassDB::bind_method(D_METHOD("get_prop_datas"), &DungeonRoomData::get_prop_datas);
ClassDB::bind_method(D_METHOD("set_prop_datas", "prop_datas"), &DungeonRoomData::set_prop_datas);
ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "prop_datas", PROPERTY_HINT_NONE, "17/17:PropData", PROPERTY_USAGE_DEFAULT, "PropData"), "set_prop_datas", "get_prop_datas");
}

12
data/dungeon_room_data.h
View File

@ -4,11 +4,21 @@
#include "core/resource.h"
#include "../main/dungeon_room.h"
#include "prop_data.h"
class DungeonRoomData : public Resource {
GDCLASS(DungeonRoomData, Resource);
public:
Ref<PropData> get_prop_data(const int index) const;
void set_prop_data(const int index, const Ref<PropData> prop_data);
void add_prop_data(const Ref<PropData> prop_data);
void remove_prop_data(const int index);
int get_prop_data_count() const;
Vector<Variant> get_prop_datas();
void set_prop_datas(const Vector<Variant> &prop_datas);
Ref<DungeonRoom> setup_room(int seed);
@ -19,7 +29,7 @@ protected:
static void _bind_methods();
private:
//Vector<VoxelmanProp> _props;
Vector<Ref<PropData> > _prop_datas;
};
#endif

89
data/planet_data.cpp
View File

@ -1,5 +1,65 @@
#include "planet_data.h"
int PlanetData::get_id() const {
return _id;
}
void PlanetData::set_id(const int value) {
_id = value;
}
Ref<FastnoiseNoiseParams> PlanetData::get_humidity_noise_params() {
return _humidity_noise_params;
}
void PlanetData::set_humidity_noise_params(Ref<FastnoiseNoiseParams> value) {
_humidity_noise_params = value;
}
Ref<FastnoiseNoiseParams> PlanetData::get_temperature_noise_params() {
return _temperature_noise_params;
}
void PlanetData::set_temperature_noise_params(Ref<FastnoiseNoiseParams> value) {
_temperature_noise_params = value;
}
Ref<BiomeData> PlanetData::get_biome_data(const int index) const {
ERR_FAIL_INDEX_V(index, _biome_datas.size(), Ref<BiomeData>());
return _biome_datas.get(index);
}
void PlanetData::set_biome_data(const int index, const Ref<BiomeData> biome_data) {
ERR_FAIL_INDEX(index, _biome_datas.size());
_biome_datas.set(index, biome_data);
}
void PlanetData::add_biome_data(const Ref<BiomeData> biome_data) {
_biome_datas.push_back(biome_data);
}
void PlanetData::remove_biome_data(const int index) {
ERR_FAIL_INDEX(index, _biome_datas.size());
_biome_datas.remove(index);
}
int PlanetData::get_biome_data_count() const {
return _biome_datas.size();
}
Vector<Variant> PlanetData::get_biome_datas() {
Vector<Variant> r;
for (int i = 0; i < _biome_datas.size(); i++) {
r.push_back(_biome_datas[i].get_ref_ptr());
}
return r;
}
void PlanetData::set_biome_datas(const Vector<Variant> &biome_datas) {
_biome_datas.clear();
for (int i = 0; i < biome_datas.size(); i++) {
Ref<BiomeData> biome_data = Ref<BiomeData>(biome_datas[i]);
_biome_datas.push_back(biome_data);
}
}
Ref<Planet> PlanetData::setup_planet(int seed) {
if (has_method("_setup_planet")) {
return call("_setup_planet", seed);
@ -9,14 +69,39 @@ Ref<Planet> PlanetData::setup_planet(int seed) {
}
PlanetData::PlanetData() {
_id = 0;
}
PlanetData::~PlanetData() {
_biome_datas.clear();
}
void PlanetData::_bind_methods() {
BIND_VMETHOD(MethodInfo(PropertyInfo(Variant::OBJECT, "biome", PROPERTY_HINT_RESOURCE_TYPE, "Planet"), "_setup_planet", PropertyInfo(Variant::INT, "seed")));
ClassDB::bind_method(D_METHOD("setup_planet", "seed"), &PlanetData::setup_planet);
ClassDB::bind_method(D_METHOD("get_id"), &PlanetData::get_id);
ClassDB::bind_method(D_METHOD("set_id", "value"), &PlanetData::set_id);
ADD_PROPERTY(PropertyInfo(Variant::INT, "id"), "set_id", "get_id");
ClassDB::bind_method(D_METHOD("get_humidity_noise_params"), &PlanetData::get_humidity_noise_params);
ClassDB::bind_method(D_METHOD("set_humidity_noise_params", "value"), &PlanetData::set_humidity_noise_params);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "humidity_noise_params", PROPERTY_HINT_RESOURCE_TYPE, "FastnoiseNoiseParams"), "set_humidity_noise_params", "get_humidity_noise_params");
ClassDB::bind_method(D_METHOD("get_temperature_noise_params"), &PlanetData::get_temperature_noise_params);
ClassDB::bind_method(D_METHOD("set_temperature_noise_params", "value"), &PlanetData::set_temperature_noise_params);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "temperature_noise_params", PROPERTY_HINT_RESOURCE_TYPE, "FastnoiseNoiseParams"), "set_temperature_noise_params", "get_temperature_noise_params");
ClassDB::bind_method(D_METHOD("get_biome_data", "index"), &PlanetData::get_biome_data);
ClassDB::bind_method(D_METHOD("set_biome_data", "index", "data"), &PlanetData::set_biome_data);
ClassDB::bind_method(D_METHOD("add_biome_data", "biome_data"), &PlanetData::add_biome_data);
ClassDB::bind_method(D_METHOD("remove_biome_data", "index"), &PlanetData::remove_biome_data);
ClassDB::bind_method(D_METHOD("get_biome_data_count"), &PlanetData::get_biome_data_count);
ClassDB::bind_method(D_METHOD("get_biome_datas"), &PlanetData::get_biome_datas);
ClassDB::bind_method(D_METHOD("set_biome_datas", "biome_datas"), &PlanetData::set_biome_datas);
ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "biome_datas", PROPERTY_HINT_NONE, "17/17:BiomeData", PROPERTY_USAGE_DEFAULT, "BiomeData"), "set_biome_datas", "get_biome_datas");
}

40
data/planet_data.h
View File

@ -1,25 +1,35 @@
#ifndef PLANET_DATA_H
#define PLANET_DATA_H
#ifndef biome_data_H
#define biome_data_H
#include "core/resource.h"
#include "../../fastnoise/fastnoise_noise_params.h"
#include "../main/planet.h"
#include "../data/biome_data.h"
class PlanetData : public Resource {
GDCLASS(PlanetData, Resource);
public:
/*
Ref<PlanetData> get_planet_data(const int index) const;
void set_planet_data(const int index, const Ref<PlanetData> planet_data);
void add_planet_data(const Ref<PlanetData> planet_data);
void remove_planet_data(const int index);
int get_id() const;
void set_id(const int value);
int get_planet_data_count() const;
Ref<FastnoiseNoiseParams> get_humidity_noise_params();
void set_humidity_noise_params(Ref<FastnoiseNoiseParams> value);
Vector<Variant> get_planet_datas();
void set_planet_datas(const Vector<Variant> &planet_datas);
*/
Ref<FastnoiseNoiseParams> get_temperature_noise_params();
void set_temperature_noise_params(Ref<FastnoiseNoiseParams> value);
Ref<BiomeData> get_biome_data(const int index) const;
void set_biome_data(const int index, const Ref<BiomeData> biome_data);
void add_biome_data(const Ref<BiomeData> biome_data);
void remove_biome_data(const int index);
int get_biome_data_count() const;
Vector<Variant> get_biome_datas();
void set_biome_datas(const Vector<Variant> &biome_datas);
Ref<Planet> setup_planet(int seed);
@ -31,10 +41,10 @@ protected:
private:
//int _id;
//Vector<BiomeData> _biome_datas;
//Ref<NoiseParams> _humidity_noise_params;
//Ref<NoiseParams> _temperature_noise_params;
int _id;
Ref<FastnoiseNoiseParams> _humidity_noise_params;
Ref<FastnoiseNoiseParams> _temperature_noise_params;
Vector<Ref<BiomeData> > _biome_datas;
};
#endif

32
data/prop_data.cpp Normal file
View File

@ -0,0 +1,32 @@
#include "prop_data.h"
bool PropData::can_spawn(int seed) {
if (has_method("_can_spawn")) {
return call("_can_spawn", seed);
}
return false;
}
Ref<VoxelmanProp> PropData::get_prop(int seed) {
if (has_method("_get_prop")) {
return call("_get_prop", seed);
}
return Ref<VoxelmanProp>(NULL);
}
PropData::PropData() {
}
PropData::~PropData() {
}
void PropData::_bind_methods() {
BIND_VMETHOD(MethodInfo(PropertyInfo(Variant::BOOL, "can"), "_can_spawn", PropertyInfo(Variant::INT, "seed")));
BIND_VMETHOD(MethodInfo(PropertyInfo(Variant::OBJECT, "prop", PROPERTY_HINT_RESOURCE_TYPE, "VoxelmanProp"), "_get_prop", PropertyInfo(Variant::INT, "seed")));
ClassDB::bind_method(D_METHOD("can_spawn", "seed"), &PropData::can_spawn);
ClassDB::bind_method(D_METHOD("get_prop", "seed"), &PropData::get_prop);
}

24
data/prop_data.h Normal file
View File

@ -0,0 +1,24 @@
#ifndef PROP_DATA_H
#define PROP_DATA_H
#include "core/resource.h"
#include "../../voxelman/props/voxelman_prop.h"
class PropData : public Resource {
GDCLASS(PropData, Resource);
public:
bool can_spawn(int seed);
Ref<VoxelmanProp> get_prop(int seed);
PropData();
~PropData();
protected:
static void _bind_methods();
};
#endif

64
main/biome.cpp
View File

@ -1,5 +1,54 @@
#include "biome.h"
//// Prop Data ////
Ref<PropData> Biome::get_prop_data(const int index) const {
ERR_FAIL_INDEX_V(index, _prop_datas.size(), Ref<PropData>());
return _prop_datas.get(index);
}
void Biome::set_prop_data(const int index, const Ref<PropData> prop_data) {
ERR_FAIL_INDEX(index, _prop_datas.size());
_prop_datas.set(index, prop_data);
}
void Biome::add_prop_data(const Ref<PropData> prop_data) {
_prop_datas.push_back(prop_data);
}
void Biome::remove_prop_data(const int index) {
ERR_FAIL_INDEX(index, _prop_datas.size());
_prop_datas.remove(index);
}
int Biome::get_prop_data_count() const {
return _prop_datas.size();
}
//// Dungeons ////
Ref<Dungeon> Biome::get_dungeon(const int index) const {
ERR_FAIL_INDEX_V(index, _dungeons.size(), Ref<Dungeon>());
return _dungeons.get(index);
}
void Biome::set_dungeon(const int index, const Ref<Dungeon> dungeon) {
ERR_FAIL_INDEX(index, _dungeons.size());
_dungeons.set(index, dungeon);
}
void Biome::add_dungeon(const Ref<Dungeon> dungeon) {
_dungeons.push_back(dungeon);
}
void Biome::remove_dungeon(const int index) {
ERR_FAIL_INDEX(index, _dungeons.size());
_dungeons.remove(index);
}
int Biome::get_dungeon_count() const {
return _dungeons.size();
}
void Biome::generate_chunk(Ref<VoxelChunk> chunk) {
if (has_method("_generate")) {
call("_generate", chunk);
@ -24,4 +73,19 @@ void Biome::_bind_methods() {
ClassDB::bind_method(D_METHOD("generate_chunk", "chunk"), &Biome::generate_chunk);
ClassDB::bind_method(D_METHOD("generate_stack", "chunk", "x", "z"), &Biome::generate_stack);
ClassDB::bind_method(D_METHOD("get_prop_data", "index"), &Biome::get_prop_data);
ClassDB::bind_method(D_METHOD("set_prop_data", "index", "data"), &Biome::set_prop_data);
ClassDB::bind_method(D_METHOD("add_prop_data", "prop_data"), &Biome::add_prop_data);
ClassDB::bind_method(D_METHOD("remove_prop_data", "index"), &Biome::remove_prop_data);
ClassDB::bind_method(D_METHOD("get_prop_data_count"), &Biome::get_prop_data_count);
ClassDB::bind_method(D_METHOD("get_dungeon", "index"), &Biome::get_dungeon);
ClassDB::bind_method(D_METHOD("set_dungeon", "index", "data"), &Biome::set_dungeon);
ClassDB::bind_method(D_METHOD("add_dungeon", "dungeon"), &Biome::add_dungeon);
ClassDB::bind_method(D_METHOD("remove_dungeon", "index"), &Biome::remove_dungeon);
ClassDB::bind_method(D_METHOD("get_dungeon_count"), &Biome::get_dungeon_count);
}

23
main/biome.h
View File

@ -4,11 +4,30 @@
#include "core/resource.h"
#include "../../voxelman/world/voxel_chunk.h"
#include "../data/prop_data.h"
#include "dungeon.h"
class Biome : public Resource {
GDCLASS(Biome, Resource);
public:
//PropData
Ref<PropData> get_prop_data(const int index) const;
void set_prop_data(const int index, const Ref<PropData> prop_data);
void add_prop_data(const Ref<PropData> prop_data);
void remove_prop_data(const int index);
int get_prop_data_count() const;
//Dungeons
Ref<Dungeon> get_dungeon(const int index) const;
void set_dungeon(const int index, const Ref<Dungeon> dungeon);
void add_dungeon(const Ref<Dungeon> dungeon);
void remove_dungeon(const int index);
int get_dungeon_count() const;
void generate_chunk(Ref<VoxelChunk> chunk);
void generate_stack(Ref<VoxelChunk> chunk, int x, int z);
@ -19,8 +38,8 @@ protected:
static void _bind_methods();
private:
//Vector<Ref<VoxelmanProp> > _props;
//Vector<Ref<Dungeon> > _dungeons;
Vector<Ref<PropData> > _prop_datas;
Vector<Ref<Dungeon> > _dungeons;
};
#endif

30
main/dungeon.cpp
View File

@ -1,5 +1,28 @@
#include "dungeon.h"
Ref<DungeonRoom> Dungeon::get_dungeon_room(const int index) const {
ERR_FAIL_INDEX_V(index, _dungeon_rooms.size(), Ref<DungeonRoom>());
return _dungeon_rooms.get(index);
}
void Dungeon::set_dungeon_room(const int index, const Ref<DungeonRoom> dungeon_room) {
ERR_FAIL_INDEX(index, _dungeon_rooms.size());
_dungeon_rooms.set(index, dungeon_room);
}
void Dungeon::add_dungeon_room(const Ref<DungeonRoom> dungeon_room) {
_dungeon_rooms.push_back(dungeon_room);
}
void Dungeon::remove_dungeon_room(const int index) {
ERR_FAIL_INDEX(index, _dungeon_rooms.size());
_dungeon_rooms.remove(index);
}
int Dungeon::get_dungeon_room_count() const {
return _dungeon_rooms.size();
}
void Dungeon::generate(Ref<VoxelStructure> structure) {
if (has_method("_generate")) {
call("_generate", structure);
@ -17,4 +40,11 @@ void Dungeon::_bind_methods() {
BIND_VMETHOD(MethodInfo("_generate", PropertyInfo(Variant::OBJECT, "structure", PROPERTY_HINT_RESOURCE_TYPE, "VoxelStructure")));
ClassDB::bind_method(D_METHOD("generate", "structure"), &Dungeon::generate);
ClassDB::bind_method(D_METHOD("get_dungeon_room", "index"), &Dungeon::get_dungeon_room);
ClassDB::bind_method(D_METHOD("set_dungeon_room", "index", "data"), &Dungeon::set_dungeon_room);
ClassDB::bind_method(D_METHOD("add_dungeon_room", "dungeon_room"), &Dungeon::add_dungeon_room);
ClassDB::bind_method(D_METHOD("remove_dungeon_room", "index"), &Dungeon::remove_dungeon_room);
ClassDB::bind_method(D_METHOD("get_dungeon_room_count"), &Dungeon::get_dungeon_room_count);
}

9
main/dungeon.h
View File

@ -3,12 +3,19 @@
#include "core/resource.h"
#include "dungeon_room.h"
#include "../../voxelman/world/voxel_structure.h"
class Dungeon : public Reference {
GDCLASS(Dungeon, Reference);
public:
Ref<DungeonRoom> get_dungeon_room(const int index) const;
void set_dungeon_room(const int index, const Ref<DungeonRoom> dungeon_room);
void add_dungeon_room(const Ref<DungeonRoom> dungeon_room);
void remove_dungeon_room(const int index);
int get_dungeon_room_count() const;
void generate(Ref<VoxelStructure> structure);
@ -20,7 +27,7 @@ protected:
private:
//Vector<Ref<DungeonRoopm> > _rooms;
Vector<Ref<DungeonRoom> > _dungeon_rooms;
};
#endif

30
main/dungeon_room.cpp
View File

@ -1,5 +1,28 @@
#include "dungeon_room.h"
Ref<PropData> DungeonRoom::get_prop_data(const int index) const {
ERR_FAIL_INDEX_V(index, _prop_datas.size(), Ref<PropData>());
return _prop_datas.get(index);
}
void DungeonRoom::set_prop_data(const int index, const Ref<PropData> prop_data) {
ERR_FAIL_INDEX(index, _prop_datas.size());
_prop_datas.set(index, prop_data);
}
void DungeonRoom::add_prop_data(const Ref<PropData> prop_data) {
_prop_datas.push_back(prop_data);
}
void DungeonRoom::remove_prop_data(const int index) {
ERR_FAIL_INDEX(index, _prop_datas.size());
_prop_datas.remove(index);
}
int DungeonRoom::get_prop_data_count() const {
return _prop_datas.size();
}
void DungeonRoom::generate_room(Ref<VoxelStructure> structure) {
if (has_method("_generate_room")) {
call("_generate_room", structure);
@ -17,4 +40,11 @@ void DungeonRoom::_bind_methods() {
BIND_VMETHOD(MethodInfo("_generate_room", PropertyInfo(Variant::OBJECT, "structure", PROPERTY_HINT_RESOURCE_TYPE, "VoxelStructure")));
ClassDB::bind_method(D_METHOD("generate_room", "structure"), &DungeonRoom::generate_room);
ClassDB::bind_method(D_METHOD("get_prop_data", "index"), &DungeonRoom::get_prop_data);
ClassDB::bind_method(D_METHOD("set_prop_data", "index", "data"), &DungeonRoom::set_prop_data);
ClassDB::bind_method(D_METHOD("add_prop_data", "prop_data"), &DungeonRoom::add_prop_data);
ClassDB::bind_method(D_METHOD("remove_prop_data", "index"), &DungeonRoom::remove_prop_data);
ClassDB::bind_method(D_METHOD("get_prop_data_count"), &DungeonRoom::get_prop_data_count);
}

10
main/dungeon_room.h
View File

@ -2,13 +2,21 @@
#define DUNGEON_ROOM_H
#include "core/reference.h"
#include "core/vector.h"
#include "../../voxelman/world/voxel_structure.h"
#include "../data/prop_data.h"
class DungeonRoom : public Reference {
GDCLASS(DungeonRoom, Reference);
public:
Ref<PropData> get_prop_data(const int index) const;
void set_prop_data(const int index, const Ref<PropData> prop_data);
void add_prop_data(const Ref<PropData> prop_data);
void remove_prop_data(const int index);
int get_prop_data_count() const;
void generate_room(Ref<VoxelStructure> structure);
@ -20,7 +28,7 @@ protected:
private:
//Vector<Ref<VoxelmanProp> > _props;
Vector<Ref<PropData> > _prop_datas;
};
#endif

30
main/planet.cpp
View File

@ -1,5 +1,28 @@
#include "planet.h"
Ref<Biome> Planet::get_biome(const int index) const {
ERR_FAIL_INDEX_V(index, _biomes.size(), Ref<Biome>());
return _biomes.get(index);
}
void Planet::set_biome(const int index, const Ref<Biome> biome) {
ERR_FAIL_INDEX(index, _biomes.size());
_biomes.set(index, biome);
}
void Planet::add_biome(const Ref<Biome> biome) {
_biomes.push_back(biome);
}
void Planet::remove_biome(const int index) {
ERR_FAIL_INDEX(index, _biomes.size());
_biomes.remove(index);
}
int Planet::get_biome_count() const {
return _biomes.size();
}
void Planet::generate_chunk(Ref<VoxelChunk> chunk) {
if (has_method("_generate_chunk")) {
call("_generate_chunk", chunk);
@ -17,4 +40,11 @@ void Planet::_bind_methods() {
BIND_VMETHOD(MethodInfo("_generate_chunk", PropertyInfo(Variant::OBJECT, "structure", PROPERTY_HINT_RESOURCE_TYPE, "VoxelChunk")));
ClassDB::bind_method(D_METHOD("generate_chunk", "chunk"), &Planet::generate_chunk);
ClassDB::bind_method(D_METHOD("get_biome", "index"), &Planet::get_biome);
ClassDB::bind_method(D_METHOD("set_biome", "index", "data"), &Planet::set_biome);
ClassDB::bind_method(D_METHOD("add_biome", "biome"), &Planet::add_biome);
ClassDB::bind_method(D_METHOD("remove_biome", "index"), &Planet::remove_biome);
ClassDB::bind_method(D_METHOD("get_biome_count"), &Planet::get_biome_count);
}

10
main/planet.h
View File

@ -4,11 +4,19 @@
#include "core/resource.h"
#include "../../voxelman/world/voxel_chunk.h"
#include "biome.h"
class Planet : public Resource {
GDCLASS(Planet, Resource);
public:
Ref<Biome> get_biome(const int index) const;
void set_biome(const int index, const Ref<Biome> biome);
void add_biome(const Ref<Biome> biome);
void remove_biome(const int index);
int get_biome_count() const;
void generate_chunk(Ref<VoxelChunk> chunk);
Planet();
@ -18,7 +26,7 @@ protected:
static void _bind_methods();
private:
//Vector<Ref<Biome> > _biomes;
Vector<Ref<Biome> > _biomes;
};
#endif

2
register_types.cpp
View File

@ -4,6 +4,7 @@
#include "data/dungeon_data.h"
#include "data/biome_data.h"
#include "data/planet_data.h"
#include "data/prop_data.h"
#include "main/dungeon_room.h"
#include "main/dungeon.h"
@ -17,6 +18,7 @@ void register_world_generator_types() {
ClassDB::register_class<DungeonData>();
ClassDB::register_class<BiomeData>();
ClassDB::register_class<PlanetData>();
ClassDB::register_class<PropData>();
ClassDB::register_class<DungeonRoom>();
ClassDB::register_class<Dungeon>();