public WaitForTargetFrameRate(MyGameTimer timer, float targetFrequency = 59.75f)
{
m_timer = timer;
m_targetFrequency = targetFrequency;
m_handler = new MyTimer.TimerEventHandler((a, b, c, d, e) =>
{
m_waiter.Set();
});
}
public WaitForTargetFrameRate(MyGameTimer timer, float targetFrequency = 59.75f)
{
m_timer = timer;
m_targetFrequency = targetFrequency;
m_handler = new MyTimer.TimerEventHandler((a, b, c, d, e) =>
{
m_waiter.Set();
});
}
/// <summary>
/// Construct Anima class.
/// </summary>
/// <remarks>Don't forget to call Init(MyEntity, string, string) to initialize!</remarks>
public Anima()
{
m_entity = null;
m_modelsFolder = null;
m_partList = new List<AnimaPart>();
m_inRange = true;
m_gameTimer = new MyGameTimer();
m_lastElapse = m_gameTimer.Elapsed.Seconds;
m_instances++;
}
private MyRenderThread(MyGameTimer timer, bool separateThread)
{
m_timer = timer;
if (separateThread)
{
SystemThread = new Thread(new ParameterizedThreadStart(RenderThreadStart));
//RenderThread.Priority = ThreadPriority.AboveNormal;
SystemThread.IsBackground = true; // Do not prevent app from terminating
SystemThread.Name = "Render thread";
SystemThread.CurrentCulture = CultureInfo.InvariantCulture;
SystemThread.CurrentUICulture = CultureInfo.InvariantCulture;
}
else
{
SystemThread = Thread.CurrentThread;
}
}
private static void Entities_OnCloseAll()
{
MyAPIGateway.Entities.OnCloseAll -= Entities_OnCloseAll;
DoTests = null;
Path = null;
Timer = null;
s_logger = null;
}
public static MyRenderThread StartSync(MyGameTimer timer, IMyRenderWindow renderWindow, MyRenderDeviceSettings? settingsToTry, MyRenderQualityEnum renderQuality)
{
var result = new MyRenderThread(timer, false);
result.m_renderWindow = renderWindow;
result.m_settings = MyRenderProxy.CreateDevice(result, renderWindow.Handle, settingsToTry);
MyRenderProxy.SendCreatedDeviceSettings(result.m_settings);
result.m_currentQuality = renderQuality;
result.m_form = System.Windows.Forms.Control.FromHandle(renderWindow.Handle);
result.LoadContent();
result.UpdateSize();
return result;
}
public static MyRenderThread Start(MyGameTimer timer, InitHandler initHandler, MyRenderDeviceSettings? settingsToTry, MyRenderQualityEnum renderQuality)
{
var result = new MyRenderThread(timer, true);
result.SystemThread.Start(new StartParams() { InitHandler = initHandler, SettingsToTry = settingsToTry, RenderQuality = renderQuality });
return result;
}
private void updateFoodLogic()
{
float elapsedMinutes = (float)(mTimer.Elapsed.Seconds / 60);
foreach (IMyPlayer player in mPlayers)
{
if (player.Controller != null && player.Controller.ControlledEntity != null && player.Controller.ControlledEntity.Entity != null)
{
PlayerData playerData = mPlayerDataStore.get(player);
IMyEntity entity = GetCharacterEntity(player.Controller.ControlledEntity.Entity);
//MyAPIGateway.Utilities.ShowMessage("DEBUG", "State: " + character.MovementState);
//if(playerData.entity != null) {
// MyAPIGateway.Utilities.ShowMessage ("DEBUG", "Entity: " + playerData.entity.Closed);
//}
float CurrentModifier = DEFAULT_MODIFIER;
if (entity is IMyCharacter)
{
MyObjectBuilder_Character character = entity.GetObjectBuilder(false) as MyObjectBuilder_Character;
if (playerData.entity == null || playerData.entity.Closed || playerData.entity.EntityId != entity.EntityId)
{
bool bReset = false;
if (!playerData.loaded)
{
bReset = true;
playerData.loaded = true;
}
else if ((playerData.entity != null) && (playerData.entity != entity)) bReset = true;
if (bReset)
{
playerData.hunger = 100f;
playerData.thirst = 100f;
}
playerData.entity = entity;
}
switch (character.MovementState)
{
case MyCharacterMovementEnum.Flying:
CurrentModifier = FLYING_MODIFIER;
break;
case MyCharacterMovementEnum.Running:
case MyCharacterMovementEnum.Backrunning:
case MyCharacterMovementEnum.RunStrafingLeft:
case MyCharacterMovementEnum.RunStrafingRight:
case MyCharacterMovementEnum.RunningRightFront:
case MyCharacterMovementEnum.RunningRightBack:
case MyCharacterMovementEnum.RunningLeftBack:
case MyCharacterMovementEnum.RunningLeftFront:
CurrentModifier = RUNNING_MODIFIER;
break;
case MyCharacterMovementEnum.Sprinting:
CurrentModifier = SPRINTING_MODIFIER;
break;
}
}
else if (playerData.entity != null || !playerData.entity.Closed) entity = playerData.entity;
// Rise the thirst
if (playerData.thirst > 0)
{
playerData.thirst -= elapsedMinutes * mThirstPerMinute * CurrentModifier;
playerData.thirst = Math.Max(playerData.thirst, 0);
}
// Rise the hunger
if (playerData.hunger > 0)
{
playerData.hunger -= elapsedMinutes * mHungerPerMinute * CurrentModifier;
playerData.hunger = Math.Max(playerData.hunger, 0);
}
// Eat
if (playerData.hunger < 30) playerEatSomething(entity, playerData);
// Drink
if (playerData.thirst < 30) playerDrinkSomething(entity, playerData);
// Get some damages for not being well feed!
if (playerData.thirst <= 0 || playerData.hunger <= 0)
{
var destroyable = entity as IMyDestroyableObject;
destroyable.DoDamage(DAMAGE_SPEED, MyStringHash.GetOrCompute("Hunger/Thirst"), true);
}
string message = MyAPIGateway.Utilities.SerializeToXML<PlayerData>(playerData);
MyAPIGateway.Multiplayer.SendMessageTo(
1337,
Encoding.Unicode.GetBytes(message),
player.SteamUserId
);
}
}
// Reinitialize the timer
mTimer = new MyGameTimer();
}
private void init()
{
mPlayerDataStore.Load();
if (Utils.isDev()) MyAPIGateway.Utilities.ShowMessage("SERVER", "INIT");
MyAPIGateway.Multiplayer.RegisterMessageHandler(1338, AdminCommandHandler);
// Minimum of 2h, because it's unplayable under....
float dayLen = Math.Max(MyAPIGateway.Session.SessionSettings.SunRotationIntervalMinutes, 120f);
mHungerPerMinute = HUNGER_PER_DAY / dayLen;
mThirstPerMinute = THIRST_PER_DAY / dayLen;
// Registering drinks
Server.RegisterBeverage("WaterFood", 10f);
Server.RegisterBeverage("CoffeeFood", 15f);
// Registering foods
Server.RegisterFood("WarmFood", 20f);
Server.RegisterFood("FreshFood", 15f);
Server.RegisterFood("GummybearsFood", 5f);
Server.RegisterFood("SyntheticFood", 3f);
// Initiate the timer
mTimer = new MyGameTimer();
}
internal MyStatToken(MyGameTimer timer, MyStat stat)
{
m_timer = timer;
m_startTime = timer.Elapsed;
m_stat = stat;
}
public void StartSync(MyGameTimer timer, IMyRenderWindow window, MyRenderDeviceSettings? settings, MyRenderQualityEnum renderQuality, float maxFrameRate)
{
RenderThread = MyRenderThread.StartSync(timer, window, settings, renderQuality, maxFrameRate);
}
/// <summary>
/// Creates and starts render thread
/// </summary>
public void Start(MyGameTimer timer, InitHandler windowInitializer, MyRenderDeviceSettings? settingsToTry, MyRenderQualityEnum renderQuality, float maxFrameRate)
{
RenderThread = MyRenderThread.Start(timer, windowInitializer, settingsToTry, renderQuality, maxFrameRate);
}
public static double GetMean(Action action, int iterations = 1, bool extraFirst = false)
{
VRage.Exceptions.ThrowIf<ArgumentNullException>(action == null, "action");
VRage.Exceptions.ThrowIf<ArgumentOutOfRangeException>(iterations < 1, "iterations < 1");
if (extraFirst)
action.Invoke();
MyGameTimer actionTimer = new MyGameTimer();
for (int i = 0; i < iterations; i++)
action.Invoke();
return actionTimer.Elapsed.Seconds / iterations;
}
/// <summary>
/// Time an Action
/// </summary>
/// <param name="action">Action to perform</param>
/// <param name="iterations">Number of iterations of action</param>
/// <param name="ignoreFirst">Perform an extra invokation first, that will not be timed.</param>
/// <returns>Results of timing</returns>
/// <exception cref="ArgumentNullException">If action == null</exception>
/// <exception cref="ArgumentOutOfRangeException">If iterarions < 1</exception>
public static Results Time(Action action, int iterations = 1, bool extraFirst = false)
{
VRage.Exceptions.ThrowIf<ArgumentNullException>(action == null, "action");
VRage.Exceptions.ThrowIf<ArgumentOutOfRangeException>(iterations < 1, "iterations < 1");
if (extraFirst)
action.Invoke();
ListSnapshots<MyTimeSpan> unsortedResults = new ListSnapshots<MyTimeSpan>(iterations);
ReadOnlyList<MyTimeSpan> mutable = unsortedResults.mutable();
for (int i = 0; i < iterations; i++)
{
MyGameTimer actionTimer = new MyGameTimer();
action.Invoke();
mutable.Add(actionTimer.Elapsed);
}
return new Results(unsortedResults);
}
public void Start()
{
timer = new MyGameTimer();
}
private void CalculateInertiaMoment()
{
m_logger.debugLog("recalculating inertia moment", Logger.severity.INFO);
MyGameTimer timer = new MyGameTimer();
List<IMySlimBlock> blocks = ResourcePool<List<IMySlimBlock>>.Get();
m_calcInertiaMoment = Vector3.Zero;
AttachedGrid.RunOnAttachedBlock(myGrid, AttachedGrid.AttachmentKind.Physics, block => {
blocks.Add(block);
return false;
}, true);
foreach (var block in blocks)
AddToInertiaMoment(block);
blocks.Clear();
ResourcePool<List<IMySlimBlock>>.Return(blocks);
using (m_lock.AcquireExclusiveUsing())
{
m_inertiaMoment = m_calcInertiaMoment;
m_invertedInertiaMoment = 1f / m_inertiaMoment;
}
m_logger.debugLog("Calculated in " + timer.Elapsed.ToPrettySeconds());
m_logger.debugLog("Inertia moment: " + m_inertiaMoment, Logger.severity.DEBUG);
m_logger.debugLog("Inverted inertia moment: " + m_invertedInertiaMoment, Logger.severity.DEBUG);
m_updating = false;
}
