💿🐜 Antkeeper source code
https://antkeeper.com
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
182 lines
5.6 KiB
182 lines
5.6 KiB
/*
|
|
* Copyright (C) 2017 Christopher J. Howard
|
|
*
|
|
* This file is part of Antkeeper Source Code.
|
|
*
|
|
* Antkeeper Source Code is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* Antkeeper Source Code is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with Antkeeper Source Code. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#ifndef NEST_HPP
|
|
#define NEST_HPP
|
|
|
|
#include <random>
|
|
#include <vector>
|
|
#include <emergent/emergent.hpp>
|
|
|
|
using namespace Emergent;
|
|
|
|
/**
|
|
* General algorithm: Draw a series of lines straight down. Select multiple elevation levels on each line at which to create a chamber. Create helixes around lines. At the selected elevation levels on each line, create a corresponding chambers on the helixes at the same elevations, in the direction of the outside of the helix. Check for intersections between chambers and tunnels, and merge as necessary.
|
|
*/
|
|
|
|
struct Chamber;
|
|
|
|
/**
|
|
* A vertically-directed helical shaft with one or more connected chambers.
|
|
*/
|
|
struct Shaft
|
|
{
|
|
Chamber* parent; // The parent chamber from which this shaft begins
|
|
std::vector<Chamber*> children; // A list of chambers which are formed from this shaft
|
|
int generation; // The generation index of this shaft. The root shaft is gen 0, the shafts from its chambers are gen 1, and so on.
|
|
Vector3 entrance; // Position of the entrance point of this shaft
|
|
float shaftRadius; // Radius of the shaft
|
|
float shaftDepth; // Total depth of this shaft
|
|
float initialHelixAngle; // Angle at which the shaft helix begins
|
|
float helixRadius; // Radius of the shaft helix
|
|
float helixPitch; // Pitch of the shaft helix
|
|
|
|
/**
|
|
* Returns the position on the shaft's helix at the specified depth.
|
|
*
|
|
* @param depth Depth relative to the entrance of this shaft.
|
|
* @return Point on the helix at the specified depth.
|
|
*/
|
|
Vector3 getHelixPosition(float depth) const;
|
|
|
|
/**
|
|
* Returns the angle to the helix at the specified depth.
|
|
*
|
|
* @param depth Depth relative to the entrance of this shaft.
|
|
* @return Angle to the helix at the specified depth.
|
|
*/
|
|
float getHelixAngle(float depth) const;
|
|
};
|
|
|
|
/**
|
|
* A horizontal annular chamber with one parent shaft and a max of one child shaft. Chambers always face toward the outside of the parent shaft's helix.
|
|
*/
|
|
struct Chamber
|
|
{
|
|
Shaft* parent; // Parent shaft from which this chamber was formed
|
|
Shaft* child; // Child shaft which begins in this chamber
|
|
int generation; // The number of chambers from this chamber to the root shaft.
|
|
float relativeDepth; // Depth from the entrance of the parent shaft to this chamber
|
|
float absoluteDepth; // Depth from the entrance of the root shaft to this chamber
|
|
float innerRadius; // Inner radius of the annulus
|
|
float outerRadius; // Outer radius of the annulus
|
|
float centralAngle; // Angle of the annular sector
|
|
float height; // Height of the annular sector
|
|
float childAngle; // The angle on the annulus at which the child shaft begins
|
|
};
|
|
|
|
/**
|
|
* Describes the parameters required to generate a nest.
|
|
*/
|
|
struct NestParameters
|
|
{
|
|
// Random params
|
|
unsigned int randomSeed;
|
|
|
|
// Shaft params
|
|
int maxShaftGeneration;
|
|
float minShaftRadius;
|
|
float maxShaftRadius;
|
|
float minShaftDepth;
|
|
float maxShaftDepth;
|
|
float minShaftHelixRadius;
|
|
float maxShaftHelixRadius;
|
|
float minShaftHelixPitch;
|
|
float maxShaftHelixPitch;
|
|
int minShaftChamberCount;
|
|
int maxShaftChamberCount;
|
|
float minShaftChamberPitch;
|
|
float maxShaftChamberPitch;
|
|
|
|
// Chamber params
|
|
float minChamberInnerRadius;
|
|
float maxChamberInnerRadius;
|
|
float minChamberOuterRadius;
|
|
float maxChamberOuterRadius;
|
|
float minChamberCentralAngle;
|
|
float maxChamberCentralAngle;
|
|
};
|
|
|
|
class Nest
|
|
{
|
|
public:
|
|
Nest();
|
|
~Nest();
|
|
|
|
/**
|
|
* Generates the nest and all of its shafts and chambers.
|
|
*/
|
|
void generate();
|
|
|
|
/**
|
|
* Sets the nest generation parameters.
|
|
*/
|
|
void setParameters(const NestParameters& parameters);
|
|
|
|
/**
|
|
* Returns the nest generation parameters.
|
|
*/
|
|
const NestParameters& getParameters() const;
|
|
|
|
/**
|
|
* Returns a pointer to the root shaft of the nest.
|
|
*/
|
|
const Shaft* getRootShaft() const;
|
|
|
|
private:
|
|
/**
|
|
* Recursive function which generates a connected system of shafts and chambers.
|
|
*
|
|
* @param parent Specifies the parent chamber of the shaft. A value of `nullptr` indicates the root shaft.
|
|
* @param generation The index of the shaft's generation. The root shaft is generation 0, the shafts formed from the root shaft's chambers are generation 1, and so on.
|
|
* @return The newly created shaft.
|
|
*/
|
|
Shaft* dig(Chamber* parent) const;
|
|
|
|
/**
|
|
* Determines intersections between chambers and connects them.
|
|
*/
|
|
void merge();
|
|
|
|
/**
|
|
* Creates a map (interconnected system of nodes) with which can be used to navigate the nest.
|
|
*/
|
|
void map();
|
|
|
|
/**
|
|
* Recursive function which deletes a shaft and all of its connect chambers and subshafts.
|
|
*
|
|
* @param Specifies a shaft to delete.
|
|
*/
|
|
void free(Shaft* shaft);
|
|
|
|
float random(float min, float max) const;
|
|
int random(int min, int max) const;
|
|
|
|
NestParameters parameters;
|
|
Shaft* root;
|
|
mutable std::default_random_engine rng;
|
|
};
|
|
|
|
inline const Shaft* Nest::getRootShaft() const
|
|
{
|
|
return root;
|
|
}
|
|
|
|
#endif // NEST_HPP
|