public void Execute(GameState state, ConfigRoot config, ICommandBuffer buffer) { state.Level.PlayerTurn = false; state.Level.MovedUnits.Clear(); LevelAiLogic.AddCommands(state, config, buffer); }
public void Execute(GameState state, ConfigRoot config, ICommandBuffer buffer) { foreach (var cmd in Childs) { buffer.Add(cmd); } }
public CommandWorkItem(ICommand command, GameState state, ConfigRoot config, ICommandBuffer buffer) { _state = state; _config = config; _buffer = buffer; Command = command; }
public void Execute(GameState state, ConfigRoot config, ICommandBuffer buffer) { var unit = state.Units[UnitId]; var maxHealth = config.Units[unit.Descriptor].MaxHealth[unit.Level]; unit.Health = maxHealth; }
public void Execute(GameState state, ConfigRoot config, ICommandBuffer _) { var item = FindItem(state); var unit = FindUnit(state); unit.Items.Add(item); state.Items.Remove(item.Id); }
public virtual void RollbackTo(int tick) { ICommandBuffer commandBuffer = this.cmdBuffer; if (commandBuffer != null) { commandBuffer.Jump(this.CurTick, tick); } }
public void BufferCommands(params Command[] commands) { if (commands == null) { return; } _commandBuffer = new ParallelCommandBuffer(commands); }
public virtual void Clean(int maxVerifiedTick) { ICommandBuffer commandBuffer = this.cmdBuffer; if (commandBuffer != null) { commandBuffer.Clean(maxVerifiedTick); } }
public void RegisterCommandBuffer(CommandBufferStage stage, ICommandBuffer commandbuffer) { var buffers = m_commandBuffer[stage]; if (!buffers.Contains(commandbuffer)) { buffers.Add(commandbuffer); } }
public void Execute(GameState state, ConfigRoot config, ICommandBuffer buffer) { var unit = state.Units[UnitId]; unit.Experience += Amount; if (unit.Experience >= config.UnitLevels[unit.Level]) { buffer.Add(new LevelUpCommand(UnitId)); } }
public void Execute(GameState state, ConfigRoot config, ICommandBuffer _) { var unit = state.Units[Id]; foreach (var item in unit.Items) { state.Items.Add(item.Id, item); } state.Units.Remove(Id); }
public void Execute(GameState state, ConfigRoot config, ICommandBuffer buffer) { var info = config.Events[EventName]; state.Events[EventName] = true; state.Progress.Remove(info.Scope); var rewardLevel = info.RewardLevel; RewardLogic.AppendReward(rewardLevel, state, config, buffer); }
public void RemoveCommandBuffer(CommandBufferStage stage, ICommandBuffer commandBuffer) { var buffers = m_commandBuffer[stage]; if (buffers.Contains(commandBuffer)) { buffers.Remove(commandBuffer); commandBuffer.Dispose(); } }
public void Execute(GameState state, ConfigRoot config, ICommandBuffer buffer) { state.Level.MovedUnits.Add(DealerId); var damage = DamageLogic.GetDamage(state, config, DealerId, TargetId); var target = state.Level.FindUnitById(TargetId); target.Health -= damage; if (target.Health <= 0) { buffer.Add(new KillUnitCommand(target.Id)); } }
public void Execute(GameState state, ConfigRoot config, ICommandBuffer buffer) { foreach (var unit in state.Level.PlayerUnits) { state.AddUnit(unit); if (!config.IsFeatureEnabled(Features.AutoHeal)) { continue; } var unitConfig = config.Units[unit.Descriptor]; if (unit.Health < unitConfig.MaxHealth[unit.Level]) { buffer.Add(new HealUnitCommand(unit.Id)); } } var levelDesc = state.Level.Descriptor; var playerUnits = state.Level.PlayerUnits; state.Level = null; if (!Win) { return; } foreach (var unit in playerUnits) { if (unit.Level >= config.UnitLevels.Length) { continue; } var expAccum = 0; foreach (var enemyDesc in config.Levels[levelDesc].EnemyDescriptors) { var enemyConfig = config.Units[enemyDesc]; expAccum += enemyConfig.Experience; } if (expAccum > 0) { buffer.Add(new AddExperienceCommand(unit.Id, expAccum)); } } var scope = LevelUtils.GetScope(levelDesc); state.Progress[scope] = Math.Min(state.Progress.GetOrDefault(scope) + 1, LevelUtils.GetIndex(levelDesc) + 1); var rewardLevel = config.Levels[levelDesc].RewardLevel; RewardLogic.AppendReward(rewardLevel, state, config, buffer); }
public void Execute(GameState state, ConfigRoot config, ICommandBuffer buffer) { var days = GetDaysBetween(state); var maxStreaks = config.DailyRewards.Length; var isNeedToDiscard = (days >= 2) || (state.DailyReward.Streak == (maxStreaks - 1)); var newStreak = isNeedToDiscard ? 0 : (state.DailyReward.Streak + 1); state.DailyReward.LastClaimDate = state.Time.GetRealTime(); state.DailyReward.Streak = newStreak; var rewardLevel = config.DailyRewards[newStreak]; RewardLogic.AppendReward(rewardLevel, state, config, buffer); }
public void Execute(GameState state, ConfigRoot config, ICommandBuffer buffer) { var item = state.Items[Id]; var upgradePrices = GetUpgradePrices(config, item.Descriptor)[item.Level]; foreach (var pair in upgradePrices) { var res = pair.Key; var price = pair.Value; buffer.Add(new SpendResourceCommand(res, price)); } item.Level++; }
protected void UpdateCommandBuffer() { if (_commandBuffer == null) { return; } if (_commandBuffer.IsCompleted) { _commandBuffer.Dispose(); _commandBuffer = null; OnBufferCompleted(); return; } _commandBuffer.RefreshBuffer(Time.deltaTime); }
public void Execute(GameState state, ConfigRoot config, ICommandBuffer _) { var playerUnits = FindPlayerUnits(state); var enemyUnits = CreateEnemyUnits(state, config); state.Level = new LevelState(LevelDesc, playerUnits, enemyUnits); state.Level.PlayerTurn = true; foreach (var unitId in PlayerUnits) { state.Units.Remove(unitId); } if (FarmLogic.IsFarmigLevel(LevelDesc, config)) { var scope = LevelUtils.GetScope(LevelDesc); state.Farming[scope] = state.Time.GetRealTime(); } }
public static void AddCommands(GameState state, ConfigRoot config, ICommandBuffer buffer) { var level = state.Level; var damages = new Dictionary <ulong, int>(); foreach (var enemy in level.EnemyUnits) { var enemyId = enemy.Id; if (!TrySelectPlayerToAttack(level.PlayerUnits, damages, out var playerUnit)) { break; } var playerId = playerUnit.Id; var attackCommand = new AttackCommand(enemyId, playerId); buffer.Add(attackCommand); var damage = DamageLogic.GetDamage(state, config, enemyId, playerId); damages[playerId] = damages.GetOrDefault(playerId) + damage; } buffer.Add(new EndEnemyTurnCommand()); }
public void Execute(GameState state, ConfigRoot config, ICommandBuffer buffer) { var unit = state.Units[UnitId]; var oldLevel = unit.Level; unit.Level++; unit.Experience -= config.UnitLevels[oldLevel]; var isLastLevel = (unit.Level == config.UnitLevels.Length); if (isLastLevel) { unit.Experience = 0; } buffer.Add(new HealUnitCommand(UnitId)); if (!isLastLevel && (unit.Experience >= config.UnitLevels[unit.Level])) { buffer.Add(new LevelUpCommand(UnitId)); } }
private void ThreadStart() { try { ICommandBuffer buff = mDevice.CreateCommandBuffer(); try { ReadWriteData(mDevice, buff, mTopOfPipeline, mIsBackup); } catch (Exception) { mDeviceSet.SignalAbort(); throw; } } catch (Exception e) { mException = e; } }
public void Execute(GameState state, ConfigRoot config, ICommandBuffer buffer) { var level = state.Level; if (TryKill(level.PlayerUnits, out var player)) { if (config.IsFeatureEnabled(Features.AutoHeal)) { buffer.Add(new HealUnitCommand(player.Id)); } state.Units.Add(UnitId, player); if (level.PlayerUnits.Count == 0) { buffer.Add(new FinishLevelCommand(false)); } } TryKill(level.EnemyUnits, out _); if (level.EnemyUnits.Count == 0) { buffer.Add(new FinishLevelCommand(true)); } }
public void Execute(GameState state, ConfigRoot config, ICommandBuffer buffer) { var health = config.Units[Descriptor].MaxHealth[0]; state.AddUnit(new UnitState(Descriptor, health).WithId(Id)); }
public Simulation(IWorld world, ICommandBuffer remoteCommandBuffer) { _world = world; _remoteCommandBuffer = remoteCommandBuffer; }
public void Execute(GameState state, ConfigRoot config, ICommandBuffer buffer) { state.Time.PersistentOffset += Amount; }
protected BaseService() { this.cmdBuffer = new CommandBuffer(); this.cmdBuffer.Init(this, this.GetRollbackFunc()); }
public void Execute(GameState state, ConfigRoot config, ICommandBuffer _) { var oldValue = state.Resources.GetOrDefault(Kind); state.Resources[Kind] = oldValue - Count; }
public void Execute(GameState state, ConfigRoot config, ICommandBuffer buffer) { buffer.Add(new AddResourceCommand(Resource.Coins, 50)); buffer.Add(new AddUnitCommand(state.NewEntityId(), "weak_unit")); }
private static void ReadWriteData(IVirtualDevice device, ICommandBuffer buff, Stream stream, bool isBackup) { while (device.GetCommand(null, buff)) { if (!buff.TimedOut) { CompletionCode completionCode = CompletionCode.DiskFull; uint bytesTransferred = 0; try { switch (buff.CommandType) { case DeviceCommandType.Write: if (!isBackup) { throw new InvalidOperationException("Cannot write in 'restore' mode"); } bytesTransferred = (uint)buff.WriteToStream(stream); completionCode = CompletionCode.Success; break; case DeviceCommandType.Read: if (isBackup) { throw new InvalidOperationException("Cannot read in 'backup' mode"); } bytesTransferred = (uint)buff.ReadFromStream(stream); if (bytesTransferred > 0) { completionCode = CompletionCode.Success; } else { completionCode = CompletionCode.HandleEof; } break; case DeviceCommandType.ClearError: completionCode = CompletionCode.Success; break; case DeviceCommandType.Flush: stream.Flush(); completionCode = CompletionCode.Success; break; default: throw new ArgumentException(string.Format("Unknown command: {0}", buff.CommandType)); } } finally { device.CompleteCommand(buff, completionCode, bytesTransferred, (ulong)0); } } } }