private void OnLevelChanged()
{
if (LevelChanged != null)
{
LevelChanged.Invoke();
}
}
void ConfigureEntityPropertyChanges()
{
OnEntityPropertyChanged(
() => LevelChanged?.Invoke(this, EventArgs.Empty),
e => e.WageDistrictLevelRates
);
}
public bool LoadLevel(string levelName)
{
//bool loaded;
bool isCube = Levels.is3DLevel(levelName);
currentData = LevelData.Load(levelName);
levelNameField.text = currentData.Name;
if (isCube)
{
SetCubeData(currentData);
}
else
{
SetBoardData(currentData);
}
//if (!loaded)
//{
// Debug.LogError("Didn't succed in loading the following level : " + levelName);
// return false;
//}
if (LevelChanged != null)
{
LevelChanged.Invoke();
}
return(true);
}
private void OnLevelReceived(float level)
{
if (LevelChanged != null)
{
LevelChanged.Invoke(level);
}
}
void SampleChannelPreVolumeMeter(object sender, StreamVolumeEventArgs e)
{
if (e?.MaxSampleValues != null)
{
LevelChanged?.Invoke(this, new LevelChangedEventArgs(e.MaxSampleValues));
}
}
private void Awake()
{
LoadProgress();
LevelChanged?.Invoke(_currentLevel);
_levelGenerator.StartLevel(_currentLevel);
}
public static void SetActiveLevel(Level level)
{
if (CurrentLevel != null)
{
// Unsubscribe
CurrentLevel.TurnCompleted -= OnLevelTurnCompleted;
CurrentLevel.TurnRollbackSucceeds -= OnLevelTurnRolledBack;
CurrentLevel.StateChanged -= OnLevelStateChanged;
CurrentLevel.StarCollected -= OnLevelStarCollected;
CurrentLevel.EntitySpawned -= OnLevelEntitySpawned;
CurrentLevel.EntityKilled -= OnLevelEntityKilled;
}
CurrentLevel = level;
// Subscribe
CurrentLevel.TurnCompleted += OnLevelTurnCompleted;
CurrentLevel.TurnRollbackSucceeds += OnLevelTurnRolledBack;
CurrentLevel.StateChanged += OnLevelStateChanged;
CurrentLevel.StarCollected += OnLevelStarCollected;
CurrentLevel.EntitySpawned += OnLevelEntitySpawned;
CurrentLevel.EntityKilled += OnLevelEntityKilled;
// Notify about level change
LevelChanged?.Invoke(CurrentLevel);
}
void UpdateScore(bool winner)
{
if (winner)
{
if (!isBonusLevel)
{
_playerScore++;
if (_playerScore == _requireToWin)
{
playerWinsCount++;
PlayerPrefs.SetInt("playerWins", playerWinsCount);
LastGoal?.Invoke();
LevelChanged?.Invoke(true);
}
}
else
{
_playerScore += 3;
}
scoreChanged?.Invoke(winner, _playerScore);
}
else
{
_enemyScore++;
scoreChanged?.Invoke(winner, _enemyScore);
if (_enemyScore == _requireToWin)
{
LastGoal?.Invoke();
LevelChanged?.Invoke(false);
}
}
}
public void LevelUp()
{
_player.AddScore(_level * _scoreMultiplier);
_level++;
LevelChanged?.Invoke(_level);
ChangeBlockColor();
}
private void refreshTimer_Tick(object sender, EventArgs e)
{
levelName = EngineFunctions.GetCurrentLevelName.Call();
if (levelName != previousLevelName)
{
LevelChanged?.Invoke(levelName);
previousLevelName = levelName;
levelNameLabel.Text = levelName;
}
RefreshData?.Invoke();
}
public void SetXP(ulong guildId, ulong userId, int xp, ulong?channelId = null)
{
var lm = GetOrCreate(guildId, userId);
var oldLevel = lm.Level;
lm.TotalXP = xp;
if (oldLevel != lm.Level)
{
LevelChanged?.Invoke(new LevelChangedArgs(guildId, userId, oldLevel, lm.Level, channelId));
}
}
private void WinLevel()
{
_objectThrower.ProhibitThrow();
_menu.HideGameplayBars();
_playerMoney.AddMoney(_totalReward);
_currentLevel++;
SaveProgress();
LevelChanged?.Invoke(_currentLevel);
_movieProducer.StartMovie();
StartCoroutine(CompleteLevelAfterMovie());
}
private void OnLevelInputChanged(string value)
{
var level = 1;
try
{
level = int.Parse(value);
}
catch (Exception exception)
{
// ignored
}
LevelChanged?.Invoke(level);
}
public void SetXp(ulong guildId, ulong userId, int xp, ulong?channelId = null)
{
var lm = GetOrCreate(guildId, userId);
var oldLevel = GetLevel(guildId, userId);
lm.TotalXP = xp;
_set.Update(lm);
_context.SaveChanges();
var newLevel = GetLevel(guildId, userId);
if (oldLevel != newLevel)
{
LevelChanged?.Invoke(new LevelChangedArgs(guildId, userId, oldLevel, newLevel, channelId));
}
}
public void GainExp()
{
exp += level;
ExpChanged?.Invoke(exp);
if (exp < expToLevel)
{
return;
}
exp %= expToLevel;
level++;
expToLevel *= level;
LevelChanged?.Invoke(level);
ExpChanged?.Invoke(exp);
}
private IEnumerator IncreaseLevel()
{
while (_cardDistributer.Cards.All(x => x.IsOpen == false) == false)
{
yield return(null);
}
Level++;
if (Level >= 10)
{
_lastTries++;
}
_tryCounter.SetTries(_lastTries);
LevelChanged?.Invoke();
_cardDistributer.AddCards(1);
}
private void waveIn_DataAvailable(object sender, WaveInEventArgs e)
{
try
{
if (!_monitoring)
{
switch (_format)
{
case "mp3":
((LameMP3FileWriter)_writer).Write(e.Buffer, 0, e.BytesRecorded);
break;
case "wav":
((WaveFileWriter)_writer).Write(e.Buffer, 0, e.BytesRecorded);
break;
}
}
//Console.WriteLine(_device.AudioMeterInformation .MasterPeakValue);
if (waveIn.WaveFormat.Channels == 2)
{
LevelChanged?.Invoke(this, new LevelChangedEventArgs((int)(Math.Round(_device.AudioMeterInformation.PeakValues[0] * 100)), (int)(Math.Round(_device.AudioMeterInformation.PeakValues[1] * 100))));
}
else
{
LevelChanged?.Invoke(this, new LevelChangedEventArgs((int)(Math.Round(_device.AudioMeterInformation.PeakValues[0] * 100)), (int)(Math.Round(_device.AudioMeterInformation.PeakValues[0] * 100))));
}
}
catch (Exception ex)
{
//Console.WriteLine(ex.Message);
StopRecord();
ChangeStatus("Error", ex.Message);
}
}
void ChangeLevelWhenTimeIsUp()
{
if (!isBonusLevel)
{
if (_playerScore > _enemyScore)
{
playerWinsCount++;
PlayerPrefs.SetInt("playerWins", playerWinsCount);
LevelChanged?.Invoke(true);
}
else
{
LevelChanged?.Invoke(false);
}
}
else
{
_playerMoney += _playerScore;
PlayerPrefs.SetInt("Money", _playerMoney);
playerWinsCount = 0;
PlayerPrefs.SetInt("playerWins", playerWinsCount);
BonusLevelEnded?.Invoke();
}
}
private void RaiseLevelChanged(ESoundGroup soundGroup, int level)
{
LevelChanged?.Invoke(this, new LevelChangedEventArgs(soundGroup, level));
}
public async Task GoTo(int level, int lvl)
{
//int min;
//int nam = 0;
//minlvl.Add(level);
//int count = minlvl.Count;
//min = Math.Abs(minlvl[0] - lvl);
//for (int i = 0; i < count; i++)
//{
// if (Math.Abs(minlvl[i] - lvl) <= min)
// {
// min = Math.Abs(minlvl[i] - lvl);
// nam = i;
// }
//}
//int lvl1 = minlvl[nam];
//int coun = minlvl.Count;
if (lvl < level)
{
State = States.EmptyClimbingUp;
StateChanged?.Invoke(this, this.State);
for (int i = lvl; i <= level; i++)
{
await Task.Delay(1000);
Level = i;
LevelChanged?.Invoke(this, this.Level);
}
await Task.Delay(1000);
State = States.OpenDoorsWaiting;
StateChanged?.Invoke(this, this.State);
await Task.Delay(1000);
State = States.EmptyWaiting;
StateChanged?.Invoke(this, this.State);
}
else
if (lvl > level)
{
State = States.EmptyClimbingDown;
StateChanged?.Invoke(this, this.State);
for (int i = lvl; i >= level; i--)
{
await Task.Delay(1000);
Level = i;
LevelChanged?.Invoke(this, this.Level);
}
await Task.Delay(1000);
State = States.OpenDoorsWaiting;
StateChanged?.Invoke(this, this.State);
await Task.Delay(1000);
State = States.EmptyWaiting;
StateChanged?.Invoke(this, this.State);
}
}
public static void OnLevelChanged(int oldValue, int newValue) => LevelChanged?.Invoke(oldValue, newValue);
private void Start()
{
LevelChanged?.Invoke(_level);
}
public LevelManager()
{
SceneManager.sceneLoaded += (scene, mode)
=> LevelChanged?.Invoke(scene.name);
}
void OnLevelChanged(BatteryLevelChangedEventArgs e)
{
LevelChanged?.Invoke(this, e);
}
public static void InvokeLevelChanged(LevelInfo level, LevelInfo previous)
{
LevelChanged?.Invoke(level, previous);
}
/// <summary> Sets the <see cref="Level"/> to the specified <paramref name="value"/>. </summary>
public LogConfiguration SetLevel(ELogLevel value)
{
Level = value ?? ELogLevel.None;
LevelChanged?.Invoke(this);
return(this);
}
//public async Task AddF( int l)
//{
// await Task.Delay(500);
// minlvl.Add(l);
//}
public async Task GoTo(int level)
{
int min;
int nam = 0;
//Data.minlvl.Add(2);
//Data.minlvl.Add(3);
//var s = Data.minlvl.ElementAt(2);
//var level = minlvl.ElementAt(0) ;
//////int count = minlvl.Count;
//////// min = Math.Abs(minlvl[0] - lvl);
//////min = Data.Cfloor;
//////for (int i = 0; i < count; i++)
//////{
////// if (Math.Abs(minlvl.ElementAt(i) - m) <= min)
////// {
////// min = Math.Abs(minlvl.ElementAt(i) - m);
////// nam = i;
////// }
//////}
//var lvl1 = minlvl.ElementAt(nam);
//minlvl.RemoveAt(nam);
//var lvl1 = 1;
//level = minlvl[nam];
if (m < level)
{
State = States.EmptyClimbingUp;
StateChanged?.Invoke(this, this.State);
for (int i = m; i <= level; i++)
{
await Task.Delay(1000);
Level = i;
LevelChanged?.Invoke(this, this.Level);
Butt?.Invoke(this, this.Level);
}
await Task.Delay(1000);
State = States.OpenDoorsWaiting;
StateChanged?.Invoke(this, this.State);
await Task.Delay(1000);
State = States.EmptyWaiting;
StateChanged?.Invoke(this, this.State);
}
else
if (m > level)
{
State = States.EmptyClimbingDown;
StateChanged?.Invoke(this, this.State);
for (int i = m; i >= level; i--)
{
await Task.Delay(1000);
Level = i;
LevelChanged?.Invoke(this, this.Level);
Butt?.Invoke(this, this.Level);
}
await Task.Delay(1000);
Butt?.Invoke(this.Level, this.Level);
State = States.OpenDoorsWaiting;
StateChanged?.Invoke(this, this.State);
await Task.Delay(1000);
State = States.EmptyWaiting;
StateChanged?.Invoke(this, this.State);
}
}
protected virtual void OnLevelChanged()
{
LevelChanged?.Invoke(this, EventArgs.Empty);
}
protected virtual void OnLevelChanged()
{
LevelChanged?.Invoke(this, new EventArgs());
}
/// <summary>
/// Raises the LevelChanged event
/// </summary>
/// <param name="levelNum"></param>
/// <param name="level"></param>
protected virtual void OnLevelChanged(int levelNum, ILevel <Board> level)
{
LevelNumChanged?.Invoke(this, levelNum);
LevelChanged?.Invoke(this, level);
}
