// Update is called once per frame
void Update()
{
if (GetComponent <Renderer>() != null)
{
GetComponent <Renderer>().enabled = SharedValues.GetInstance().areWallsShown;
}
}
public void ReplaceSharedVal(SharedValues newValue)
{
var index = GameComponentsLookup.SharedVal;
var component = CreateComponent <SharedValComponent>(index);
component.value = newValue;
ReplaceComponent(index, component);
}
public static SharedValues GetInstance()
{
if (sharedValues == null)
{
sharedValues = new SharedValues();
}
return(sharedValues);
}
// Use this for initialization
void Start()
{
sharedValues = SharedValues.GetInstance();
switch (sharedValues.level)
{
case 0:
SceneManager.LoadScene("level1");
break;
}
}
public GameEntity SetSharedVal(SharedValues newValue)
{
if (hasSharedVal)
{
throw new Entitas.EntitasException("Could not set SharedVal!\n" + this + " already has an entity with SharedValComponent!",
"You should check if the context already has a sharedValEntity before setting it or use context.ReplaceSharedVal().");
}
var entity = CreateEntity();
entity.AddSharedVal(newValue);
return(entity);
}
public void ReplaceSharedVal(SharedValues newValue)
{
var entity = sharedValEntity;
if (entity == null)
{
entity = SetSharedVal(newValue);
}
else
{
entity.ReplaceSharedVal(newValue);
}
}
public void ConvertLog(IEncounterLog herosLog, SharedValues sharedValues)
{
herosLog.Name = sharedValues.Target;
herosLog.EncounterDate = sharedValues.LogStart.ToLocalTime();
herosLog.EncounterResult = sharedValues.Success ? "Success" : "Fail";
var time = TimeSpan.FromSeconds(sharedValues.FightDuration);
herosLog.EncounterTime = new TimeSpan(time.Days, time.Hours, time.Minutes, time.Seconds);
foreach (var sharedValuesPlayerValue in sharedValues.PlayerValues)
{
var characterStats = new CharacterStatistics()
{
Name = sharedValuesPlayerValue.Character,
DisplayName = sharedValuesPlayerValue.Account.Substring(1),
BossDps = Math.Round(sharedValuesPlayerValue.DPSBoss),
BossDamage = sharedValuesPlayerValue.TotalBoss,
AllDps = Math.Round(sharedValuesPlayerValue.DPSAll),
AllDamage = sharedValuesPlayerValue.TotalAll,
Down = sharedValuesPlayerValue.Down.ToString(),
Role = sharedValuesPlayerValue.Profession,
};
if (sharedValuesPlayerValue.Dead &&
sharedValuesPlayerValue.FightDurationPlayer < sharedValues.FightDuration)
{
var percent = (sharedValuesPlayerValue.FightDurationPlayer / sharedValues.FightDuration * 100).ToString("0");
var timeOfDead = TimeSpan.FromSeconds(sharedValuesPlayerValue.FightDurationPlayer);
characterStats.Dead = $"{timeOfDead.Minutes}m {timeOfDead.Seconds}s ({percent}% alive)";
}
AddSkills(sharedValuesPlayerValue.Skills, characterStats);
herosLog.CharacterStatistics.Add(characterStats);
}
herosLog.BossDps =
Math.Round(sharedValues.PlayerValues.Sum(i => i.TotalBoss) / sharedValues.FightDuration);
herosLog.AllDps =
Math.Round(sharedValues.PlayerValues.Sum(i => i.TotalAll) / sharedValues.FightDuration);
}
// Use this for initialization
void Awake()
{
FixedParameters.generateParameters(wallDistance, numRows, numCols, trapCount, numHoles,
Mathf.CeilToInt(timeout * 60), numGuards, Mathf.CeilToInt(timeDeduction * 60), Mathf.CeilToInt(timeInvincible * 60),
requireInitialInstructions);
SharedValues sharedValues = SharedValues.GetInstance();
sharedValues.timeLeft = Mathf.CeilToInt(gameTime * 60);
sharedValues.level = level;
// other stuff
sharedValues.holesSpawned = 0;
sharedValues.wallFrames = 0;
sharedValues.areWallsShown = true;
sharedValues.trapDisplayState = 1;
sharedValues.trapDisplayStateTime = 120;
sharedValues.isStunned = false;
sharedValues.stunnedTime = 0;
sharedValues.hasGameStarted = false;
sharedValues.isGameOver = false;
sharedValues.win = false;
}
public SpanListModel(
IReadOnlyList <TSpan> spans,
IEqualityComparer <TSharedKey> sharedKeyComparer = null,
IComparer <TSharedKey> sharedKeySorter = null,
IComparer <TShared> sharedValueSorter = null)
: this()
{
Optimize = true;
Count = spans.Count;
List <TSharedKey> sharedKeys = new List <TSharedKey>();
Dictionary <TSharedKey, int> sharedMap = new Dictionary <TSharedKey, int>(sharedKeyComparer ?? EqualityComparer <TSharedKey> .Default);
foreach (var span in spans)
{
var sharedKey = GetSharedKey(span);
if (!sharedMap.ContainsKey(sharedKey))
{
sharedMap.Add(sharedKey, SharedValues.Count);
SharedValues.Add(GetShared(span));
sharedKeys.Add(sharedKey);
}
}
if (sharedValueSorter != null || sharedKeySorter != null)
{
TSharedKey[] sharedKeyArray = sharedKeys.ToArray();
TShared[] sharedValueArray = SharedValues.ToArray();
if (sharedValueSorter != null)
{
Array.Sort(sharedValueArray, sharedKeyArray, sharedValueSorter);
}
else
{
Array.Sort(sharedKeyArray, sharedValueArray, sharedKeySorter);
}
// Ensure shared keys is not used after this point
sharedKeys = null;
SharedValues.Clear();
SharedValues.AddRange(sharedValueArray);
for (int index = 0; index < sharedKeyArray.Length; index++)
{
sharedMap[sharedKeyArray[index]] = index;
}
}
var segmentsLength = NumberUtils.Ceiling(spans.Count, SegmentSpanCount);
int offset = 0;
for (int segmentIndex = 0; segmentIndex < segmentsLength; segmentIndex++, offset += SegmentSpanCount)
{
var length = Math.Min(SegmentSpanCount, spans.Count - offset);
if (length == 0)
{
break;
}
var segmentSpans = new ListSegment <TSpan>(spans, offset, length);
var segment = CreateSegment(segmentSpans);
Segments.Add(segment);
var firstSpanStart = segmentSpans[0].Start;
var lastSpan = segmentSpans[length - 1];
segment.Starts = IntegerListModel.Create(segmentSpans, s => GetStart(s, SharedValues[sharedMap[GetSharedKey(s)]]));
segment.Lengths = IntegerListModel.Create(segmentSpans, s => s.Length);
segment.FullLength = (lastSpan.Start + lastSpan.Length) - firstSpanStart;
segment.SharedIndices = IntegerListModel.Create(segmentSpans, s => sharedMap[GetSharedKey(s)]);
}
}
