// Use this for initialization
void Start()
{
tempManager = gameObject.GetComponent <TemperatureManager>();
currentHunger = maxHunger;
currentThirst = maxThirst;
currentHealth = maxHealth;
currentFatigue = maxFatigue;
currentStamina = maxStamina;
}
public void Update_DoesNotThrowException()
{
// Create a test provider and store
ITemperatureProvider provider = new FakeTemperatureProvider();
ITemperatureStore store = new MemoryTemperatureStore();
// Inject the test dependencies
TemperatureManager testTemperatureManager = new TemperatureManager(provider, store);
Assert.DoesNotThrow(() => testTemperatureManager.Update());
}
public override void _Process(float delta)
{
int camX = int.Parse(Mathf.Stepify(Camera.Transform.origin.x / ChunkSize.x, 1).ToString());
int camZ = int.Parse(Mathf.Stepify(Camera.Transform.origin.z / ChunkSize.z, 1).ToString());
for (int x = -RenderDistance; x <= RenderDistance; x++)
{
for (int y = -RenderDistance; y <= RenderDistance; y++)
{
var pos = new Vector2(x + camX, y + camZ);
if (!PreloadedChunks.ContainsKey(pos) && !LoadedChunks.ContainsKey(pos) && !toRenderPos.Contains(pos))
{
toRenderPos.Enqueue(pos);
}
}
}
var temp = TemperatureManager.GetTemperature((int)(Camera.Transform.origin.x), (int)(Camera.Transform.origin.z));
var hum = TemperatureManager.GetHumidity((int)(Camera.Transform.origin.x), (int)(Camera.Transform.origin.z));
InfoLabel.Clear();
//InfoLabel.Text += "FPS: " + Engine.GetFramesPerSecond() + "\n";
InfoLabel.Text += "PreloadedCount: " + PreloadedChunks.Count.ToString() + "\n";
InfoLabel.Text += "LoadedChunksCount: " + LoadedChunks.Count.ToString() + "\n";
InfoLabel.Text += "ToRenderCount: " + toRenderPos.Count.ToString() + "\n";
InfoLabel.Text += "CamPosition: " + "X: " + camX + " Z: " + camZ + "\n";
InfoLabel.Text += "Current Temperature: " + temp + "\n";
InfoLabel.Text += "Current Humidity: " + hum + "% \n";
InfoLabel.Text += "Current biome: " + BiomeManager.FindMatchingBiome(temp, hum).ToString();
foreach (var item in LoadedChunks.Keys)
{
if (DistanceToChunk(item) >= RenderDistance * 2)
{
Chunk chunk = LoadedChunks[item];
if (!HasNode("item.ToString()"))
{
continue;
}
var node = GetNode(item.ToString());
node.CallDeferred("free");
LoadedChunks.TryRemove(item, out chunk);
}
}
}
private static float GetMatch(float temp, float humidity, BiomeSettings biome)
{
float realTemp, realHum, realTargetTemp, realTargetHum;
float targetTemp = biome.TargetTemperature;
float targetHum = biome.TargetHumidity;
realTemp = (TemperatureManager.GetOriginalTemperature(temp) - 1f) / 2;
realHum = humidity / 100f;
realTargetTemp = (TemperatureManager.GetOriginalTemperature(targetTemp) - 1f) / 2;
realTargetHum = targetHum / 100f;
float diffTemp = realTemp > realTargetTemp ? realTargetTemp - realTemp : realTemp - realTargetTemp;
float diffHum = realHum > realTargetHum ? realTargetHum - realHum : realHum - realTargetHum;
return(1f + (diffTemp + diffHum));
}
private void Construct(TemperatureManager _temperatureManager,
SensorInfoManager _sensorInfoManager)
{
temperatureManager = _temperatureManager;
sensorInfoManager = _sensorInfoManager;
}
// This is called by GameManagerObject's Awake() - Scene objects are initialised for pointers
public static void LevelLoadBegin(float m_Roomtemperature, float m_Temperaturechange, float m_Abilitytemperaturechange, float levelLength)
{
// Initialise managers.
temperatureValues[0] = m_Roomtemperature;
temperatureValues[1] = m_Temperaturechange;
temperatureValues[2] = m_Abilitytemperaturechange;
m_LevelLength = levelLength;
GameObject o;
o = Object.Instantiate(Resources.Load(UIMANAGER_NAME)) as GameObject;
g_pUIManager = o.GetComponent<UIManager>();
o = Object.Instantiate(Resources.Load(GAMERULES_NAME)) as GameObject;
g_pGameRules = o.GetComponent<GameRules>();
o = Object.Instantiate(Resources.Load(TEMPERATUREMANAGER_NAME)) as GameObject;
g_pTemperatureManager = o.GetComponent<TemperatureManager>();
// Grab the player from the scene.
g_pPlayer = GameObject.FindGameObjectWithTag(PLAYER_NAME).GetComponent<Player>();
}
public bool Initialize()
{
var logConfig = new LoggingConfiguration();
logConfig.AddTarget(new ConsoleTarget("console")
{
DetectConsoleAvailable = true,
Layout = Layout.FromString("${time}: ${message}")
});
logConfig.AddRuleForAllLevels("console");
LogManager.Configuration = logConfig;
Logger.Info($"{new string('=', 64)}");
Logger.Info("Initializing...");
var pluginAssemblies = Directory.GetFiles($@"{AppDomain.CurrentDomain.BaseDirectory}\Plugins", "*.dll", SearchOption.AllDirectories)
.Where(f => AppDomain.CurrentDomain.GetAssemblies().All(a => a.Location != f))
.TrySelect(Assembly.LoadFile, ex => { })
.ToList();
AppDomain.CurrentDomain.AssemblyResolve += (sender, args) =>
pluginAssemblies.FirstOrDefault(a => string.CompareOrdinal(a.FullName, args.Name) == 0);
Logger.Info("Loading plugins...");
foreach (var assembly in pluginAssemblies)
{
Logger.Info("Loading assembly: {0} [{1}]", assembly.GetName().Name, assembly.GetName().Version);
}
_cache = new DataCache();
_configManager = new ConfigManager("config.json");
_configManager.LoadOrCreateConfig();
_sensorManager = new SensorManager();
var alpha = Math.Exp(-_configManager.CurrentConfig.TemperatureTimerInterval / (double)_configManager.CurrentConfig.DeviceSpeedTimerInterval);
var providerFactory = new MovingAverageTemperatureProviderFactory(alpha);
_temperatureManager = new TemperatureManager(_sensorManager.TemperatureSensors.ToList(), providerFactory);
_effectManager = new EffectManager();
_speedControllerManager = new SpeedControllerManager();
_deviceManager = new DeviceManager();
_deviceManager.Accept(_cache.AsWriteOnly());
Logger.Info("Applying config...");
_configManager.Accept(_cache.AsWriteOnly());
foreach (var profile in _configManager.CurrentConfig.Profiles)
{
foreach (var effect in profile.Effects)
{
_effectManager.Add(profile.Guid, effect);
}
foreach (var speedController in profile.SpeedControllers)
{
_speedControllerManager.Add(profile.Guid, speedController);
}
_temperatureManager.EnableSensors(_speedControllerManager.GetSpeedControllers(profile.Guid)?.SelectMany(c => c.UsedSensors));
_temperatureManager.EnableSensors(_effectManager.GetEffects(profile.Guid)?.SelectMany(e => e.UsedSensors));
}
ApplyComputerStateProfile(ComputerStateType.Boot);
_timerManager = new TimerManager();
_timerManager.RegisterTimer(_configManager.CurrentConfig.TemperatureTimerInterval, TemperatureTimerCallback);
_timerManager.RegisterTimer(_configManager.CurrentConfig.DeviceSpeedTimerInterval, DeviceSpeedTimerCallback);
_timerManager.RegisterTimer(_configManager.CurrentConfig.DeviceRgbTimerInterval, DeviceRgbTimerCallback);
if (Environment.UserInteractive)
{
_timerManager.RegisterTimer(_configManager.CurrentConfig.LoggingTimerInterval, LoggingTimerCallback);
}
_timerManager.Start();
Logger.Info("Initializing done!");
Logger.Info($"{new string('=', 64)}");
return(true);
}
static void Main(string[] args)
{
TemperatureManager temperatureManager = new TemperatureManager();
temperatureManager.Update();
}
// Start is called before the first frame update
void Awake()
{
Instance = this;
temperatureOffset.x = UnityEngine.Random.Range(-100f, 100f);
}
// Use this for initialization
void Start()
{
tempManage = GetComponent <TemperatureManager>();
}
public void GetChunkData(Chunk chunk)
{
// Chunk global position.
var Offset = chunk.Offset;
// Settings !
float temperature = TemperatureManager.GetTemperature(0 + (int)(Offset.x * ChunkSize.x), 0 + (int)(Offset.y * ChunkSize.z));
float humidity = TemperatureManager.GetHumidity(0 + (int)(Offset.x * ChunkSize.x), 0 + (int)(Offset.y * ChunkSize.z));
BiomeSettings CurrentSettings = BiomeManager.BestMatch(temperature, humidity);
bool placedTree = false;
for (int z = 0; z < ChunkSize.z; z += 1)
{
for (int x = 0; x < ChunkSize.x; x += 1)
{
temperature = TemperatureManager.GetTemperature(x + (int)(chunk.Offset.x * ChunkSize.x), z + (int)(chunk.Offset.y * ChunkSize.z));
humidity = TemperatureManager.GetHumidity(x + (int)(chunk.Offset.x * ChunkSize.x), z + (int)(chunk.Offset.y * ChunkSize.z));
CurrentSettings = BiomeManager.BestMatch(temperature, humidity);
// Global position of the cube.
int gX = ((int)Offset.x * (int)Chunk.ChunkSize.x) + x;
int gZ = ((int)Offset.y * (int)Chunk.ChunkSize.z) + z;
float noiseResult = ((Noise.GetNoise2d(gX, gZ) * CurrentSettings.TerrainAmplitude) + 1f) * (ChunkSize.y / 2);
float height = Mathf.Clamp(Mathf.Stepify(noiseResult, 1), 0, 254);
// Default type
BlockType type = CurrentSettings.DefaultBlocktype;
// Filling under the chunk too.
for (int i = 0; i <= height; i++)
{
chunk.Voxels[x, i, z].Active = true;
chunk.Voxels[x, i, z].Type = type;
}
// Big mountains?
if (CurrentSettings.Mountains)
{
GenerateMountains(chunk, x, z, (int)Mathf.Clamp(height, 0f, 254f));
}
// Add X layers of block on top of the generated rock.
var pos = chunk.HighestAt(x, z);
for (int i = 0; i < CurrentSettings.TopLayerThickness; i++)
{
// Adding some dirt under top layer.
var newType = CurrentSettings.UnderLayerType;
// if highest block, its grass!
if (i == 0)
{
newType = CurrentSettings.TopLayerType;
}
// Placing block. Making sure its under 255 height.
chunk.Voxels[x, Mathf.Clamp(pos - i, 0, 254), z].Type = newType;
}
// Placing decoration
int decorationChance = rng.RandiRange(1, 100);
if (decorationChance < CurrentSettings.DecorationRate)
{
// Placing point
int dy = chunk.HighestAt(x, z) + 1;
var mesh = (ArrayMesh)ResourceLoader.Load(CurrentSettings.DecorationModel);
chunk.AddVoxelSprite(new VoxelSprite(mesh, new Vector3(x, dy, z)));
}
// Placing trees
float treeChance = rng.RandfRange(1f, 100f);
//GD.Print(treeChance + " <= " + CurrentSettings.TreeRate);
if (treeChance < CurrentSettings.TreeRate)
{
//GD.Print("Placed tree");
var file = (ArrayMesh)ResourceLoader.Load(CurrentSettings.TreeModel);
int ty = chunk.HighestAt(x, z) + 1;
//Placing point.
// Creating and setting the mesh.
var meshInstance = new MeshInstance();
meshInstance.Mesh = file;
meshInstance.Name = CurrentSettings.TreeModel;
// Adding it next frame.(safe with mutex lock)
CallDeferred("add_child", meshInstance);
// Moving it next frame(not in the tree yet :))
meshInstance.SetDeferred("translation", new Vector3(x + (Offset.x * ChunkSize.x) - 10, ty,
z + (Offset.y * ChunkSize.z + 10)));
//meshInstance.SetDeferred("rotation_degrees", new Vector3(0, rng.RandfRange(0, 360), 0));
}
}
}
}
