public void MakeNewGeneration(IRules rules)
{
var actualBoard = BoardValues.ConvertAll(e => new GamePixel(e.X, e.Y, e.IsAlive()));
Parallel.For(0, actualBoard.Count, i =>
{
var actualPixel = actualBoard[i];
var neighborhoods = GetNeighborhoodsNumber(i, WidthElementsNumber, HeightElementsNumber, actualBoard);
var decision = rules.ChangeState(neighborhoods, actualPixel.IsAlive());
switch (decision)
{
case ToState.ToDead:
BoardValues[i].Kill();
break;
case ToState.ToLive:
BoardValues[i].Revive();
break;
case ToState.DoNotChange:
break;
default:
throw new ArgumentOutOfRangeException();
}
});
}
/// <summary>
/// Restituiesce un sensore generico senza funzione di scalatura, gli input non vengono scalati
/// </summary>
/// <param name="name"></param>
/// <param name="id"></param>
/// <param name="rules"></param>
protected AbstractSensor(
string name,
int id,
IRules <Tin> rules) : this(name, id)
{
Rules = rules;
}
public RulesPanelViewModel(RuleViewModelFactory ruleViewModelFactory, PropertiesPanelViewModel propertiesPanelViewModel, IRules rules)
: base("Rules")
{
_propertiesPanelViewModel = propertiesPanelViewModel;
_rules = rules;
IsExpanded = true;
}
public RulerBase(IModifierBus bus, IRules rules, ISubject<IInfo> infoChannel)
{
_bus = bus;
_rules = rules;
_infoChannel = infoChannel;
}
public static void Main(string[] args)
{
output = new ConsoleOutput();
input = new ConsoleInput();
board = new Board();
rules = new MainRules();
board.MakeBoard(11);
players = GetPlayers();
bool preparedToStart = rules.PrepareNewGame(board, players);
if (preparedToStart)
{
output.PrintString(rules.GetIntro());
output.ShowBoard(board.GetBoard());
//main loop
while (rules.GameContinues())
{
int[][] move = input.GetMoveFromPlayer();
rules.ApplyMove(move);
output.ShowBoard(board.GetBoard());
}
}
else
{
output.PrintString("Program unable to prepare game, aborting.");
}
}
public Map(bool[,] state, IRules rules)
{
_state = state;
_rules = rules;
_xLenght = _state.GetLength(0);
_yLenght = _state.GetLength(1);
}
public Candidate(
CurrentState currentState,
IFiniteStateMachine fsm,
List <IPeer> peers,
ILog log,
IRandomDelay random,
INode node,
ISettings settings,
IRules rules,
ILoggerFactory loggerFactory)
{
try
{
_logger = loggerFactory.CreateLogger <Candidate>();
}
catch (ObjectDisposedException e)
{
//happens because asp.net shuts down services sometimes before onshutdown
}
_rules = rules;
_random = random;
_node = node;
_settings = settings;
_log = log;
_peers = peers;
_fsm = fsm;
CurrentState = currentState;
StartElectioneering();
ResetElectionTimer();
}
/// <summary>
/// Initializes a SubBoard from the state given by its parameters.
/// </summary>
/// <param name="rules"></param>
/// <param name="board"></param>
/// <param name="isActive"></param>
/// <param name="winner"></param>
public SubBoard(IRules rules, MarkerType[,] board, bool isActive, MarkerType winner)
{
_rules = rules;
Winner = winner;
IsActive = isActive;
_board = board;
}
public void Should_Check_LoopThroughEachCell(int cellX, int cellY, State expected) // TODO: change method name
{
// arrange
var fileInput = new FileReader();
var grid = new Universe(fileInput);
var gridLength = 3;
var gridWidth = 3;
grid.SetUpGrid(gridLength, gridWidth);
grid.Initialise();
var rules = new IRules[]
{
new OvercrowdingRule(grid),
new ReproductionRule(grid),
new SurvivalRule(grid),
new UnderpopulationRule(grid)
};
var logger = new Mock <ILogger <GameController> >();
var game = new GameController(grid, logger.Object, fileInput);
// act
game.LoopThroughEachCell();
// assert
Assert.Equal(expected, grid.Grid[cellX, cellY].CellState);
}
public void AddComponent(Discipline discipline, IRules rules, double coeficient)
{
var component = new ResultsListColumnComponent(discipline, rules, coeficient);
this.components.Add(component);
isSingleDiscipline = coeficient == 1.0f && this.components.Count == 1;
hasFinalPoints = components.All(c => c.Rules.HasPoints); // all disciplines support points
primaryComponent = components.Select(c => c.Rules.PrimaryComponent).FirstOrDefault();
hasSecondaryDuration = components.Select(c => c.Rules.HasDuration && c.Rules.PrimaryComponent == PerformanceComponent.Duration).FirstOrDefault();
bool hasPerformance = components.Select(c => c.Rules.Name).Distinct().Count() == 1; // all disciplines have same rules
if (!hasPerformance)
{
primaryComponent = PerformanceComponent.None;
hasSecondaryDuration = false;
}
if (!discipline.AnnouncementsPublic)
{
allowAnnouncements = allowPrivateData;
}
if (!discipline.ResultsPublic)
{
allowResults = allowPrivateData;
}
}
/// <summary>
/// Add a new rule to our engine, its key is the settings section in the web.config
/// </summary>
/// <param name="SettingsSection"></param>
/// <param name="NewRule"></param>
public void AddRule(string SettingsSection, IRules NewRule)
{
if (!rules.ContainsKey(SettingsSection))
{
rules.Add(SettingsSection, NewRule);
}
}
/// <summary>
/// Create menu.
/// </summary>
/// <param name="rules">'Game of life' rules implementation</param>
public Menu(IRules rules, IPlayerInterface playerInterface, ISaveManager saveManager)
{
_playerInterface = playerInterface;
_saveManager = saveManager;
_gameRepo = new GameRepository();
_gameManager = new (playerInterface, _gameRepo, rules);
}
/// <summary>
/// Calculate new states for each cell. Using specified rules.
/// </summary>
private void CalculateNextGeneration(IRules rules)
{
foreach (Cell cell in Grid)
{
cell.CalculateNextState(rules);
}
}
public RulesTest()
{
this.storageAdapter = new Mock <IStorageAdapterClient>();
this.asaManager = new Mock <IAsaManagerClient>();
this.logger = new Mock <ILogger <Rules> >();
this.config = new AppConfig
{
ExternalDependencies = new ExternalDependenciesConfig
{
DiagnosticsServiceUrl = "http://localhost:9006/v1",
DiagnosticsMaxLogRetries = 3,
},
};
this.rulesMock = new Mock <IRules>();
this.alarms = new Mock <IAlarms>();
this.httpClientMock = new Mock <IHttpClient>();
this.httpContextAccessor = new Mock <IHttpContextAccessor>();
this.diagnosticsClient = new DiagnosticsClient(this.httpClientMock.Object, this.config, new Mock <ILogger <DiagnosticsClient> >().Object, this.httpContextAccessor.Object);
this.httpContextAccessor
.Setup(t => t.HttpContext.Request.HttpContext.Items)
.Returns(new Dictionary <object, object>()
{
{ "TenantID", TenantId },
});
this.asaManager
.Setup(t => t.BeginRulesConversionAsync())
.ReturnsAsync(new BeginConversionApiModel());
this.rules = new Rules(this.storageAdapter.Object, this.asaManager.Object, this.logger.Object, this.alarms.Object, this.diagnosticsClient);
}
/// <summary>
/// A default implementation for validating entities and behaviors using the specified rules.
/// </summary>
/// <param name="rules">The rules.</param>
/// <param name="entities">The entities.</param>
/// <exception cref="ValidationFailedException">Thrown if the validation failed.</exception>
protected void Validate(IRules rules, IEntityCollection entities)
{
if (rules == null)
{
return;
}
if (entities != null)
{
foreach (var entity in entities)
{
if (entity is IRuleSubject subject)
{
subject.Apply(rules);
}
}
}
foreach (var behavior in EntityBehaviors.SelectMany(p => p))
{
if (behavior is IRuleSubject subject)
{
subject.Apply(rules);
}
}
// Are there still violated rules?
if (rules.ViolationCount > 0)
{
throw new ValidationFailedException(this, rules);
}
}
/// <summary>
/// Initializes an empty Board using the given <paramref name="rules"/>.
/// </summary>
/// <param name="rules">The rules that the board will adhere to.</param>
public Board(IRules rules)
{
_rules = rules;
Winner = MarkerType.Empty;
SubBoards = new SubBoard[BoardSize, BoardSize];
InitializeSubBoards();
}
/// <summary>
/// Initializes an empty SubBoard that will use the given <paramref name="rules"/>.
/// </summary>
/// <param name="rules">The rules that this SubBoard will adhere to.</param>
public SubBoard(IRules rules)
{
_rules = rules;
Winner = MarkerType.Empty;
_board = new MarkerType[SubBoardSize, SubBoardSize];
IsActive = false;
InitializeEmptyBoard();
}
public StrategyService(IRules rules)
{
_strategiesMap = new Dictionary <EStrategies, IStrategy>
{
{ EStrategies.Aggressive, new AggressiveStrategy(rules) },
{ EStrategies.Defensive, new DefensiveStrategy(rules) },
};
}
/// <summary>
/// Basic constructor.
/// </summary>
/// <param name="gameView">Game window handler.</param>
/// <param name="gameRepo">Repository with games.</param>
/// <param name="rules">'Game of life' rules implementation</param>
public GameManager(IGameView gameView, IGameRepository gameRepo, IRules rules)
{
_gameView = gameView;
_gameRepo = gameRepo;
_rules = rules;
_gamesOnScreen = new GameRepository();
SetupTimer();
}
public LifeProcess(ICellService cellService, IRules rules)
{
OldGeneration = new List <Cell>();
NewGeneration = new List <Cell>();
_cellService = cellService;
_neighbours = new List <Cell>();
Rules = rules;
}
public Game(IBoard board, IRules rules)
{
Board = board;
this.rules = rules;
this.player1 = new Player(State.Red);
this.player2 = new Player(State.Yellow);
ActivePlayer = this.player1;
}
public RequestVoteTests()
{
_rules = new Rules();
_settings = new InMemorySettingsBuilder().Build();
_random = new RandomDelay();
_log = new InMemoryLog();
_peers = new List <IPeer>();
_node = new NothingNode();
}
public RulesTest()
{
this.storageAdapter = new Mock <IStorageAdapterClient>();
this.logger = new Mock <ILogger>();
this.servicesConfig = new Mock <IServicesConfig>();
this.rulesMock = new Mock <IRules>();
this.alarms = new Mock <IAlarms>();
this.rules = new Rules(this.storageAdapter.Object, this.logger.Object, this.alarms.Object);
}
public AlarmsByRuleController(
IAlarms alarmService,
IRules ruleService,
ILogger logger)
{
this.alarmService = alarmService;
this.ruleService = ruleService;
this.log = logger;
}
/// <summary>
/// Restituisce un sensore generico che usa una funzione di scalatura per calcolare il valore gli input
/// </summary>
/// <param name="name"></param>
/// <param name="id"></param>
/// <param name="scaleFunction"></param>
/// <param name="rules"></param>
protected AbstractSensor(
string name,
int id,
IScale <Tin, Tout> scaleFunction,
IRules <Tin> rules) : this(name, id, rules)
{
Console.WriteLine($"Abstract_{Type}_created({Id})");
ScaleFunction = scaleFunction;
}
public AppendEntriesTests()
{
_rules = new Rules();
_settings = new InMemorySettingsBuilder().Build();
_random = new RandomDelay();
_log = new InMemoryLog();
_peers = new List <IPeer>();
_fsm = new InMemoryStateMachine();
_node = new NothingNode();
}
public AllServersConvertToFollowerTests()
{
_rules = new Rules();
_settings = new InMemorySettingsBuilder().Build();
_random = new RandomDelay();
_log = new InMemoryLog();
_peers = new List <IPeer>();
_fsm = new InMemoryStateMachine();
_node = new NothingNode();
}
public RequestVoteTests()
{
_loggerFactory = new Mock <ILoggerFactory>();
_rules = new Rules(_loggerFactory.Object, new NodeId(default(string)));
_settings = new InMemorySettingsBuilder().Build();
_random = new RandomDelay();
_log = new InMemoryLog();
_peers = new List <IPeer>();
_node = new NothingNode();
}
public static string Compute(int i)
{
Divider = new DivisibleRules();
Contener = new ContentRules();
string message = string.Empty;
message = Divider.Apply(i);
message = message += Contener.Apply(i);
return(string.IsNullOrEmpty(message) ? i.ToString() : message);
}
/// <inheritdoc/>
void IRuleSubject.Apply(IRules rules)
{
var p = rules.GetParameterSet <ComponentRuleParameters>();
var nodes = Nodes.Select(name => p.Factory.GetSharedVariable(name)).ToArray();
foreach (var rule in rules.GetRules <IConductiveRule>())
{
rule.AddPath(this, ConductionTypes.None, nodes[0], nodes[1]);
}
}
public AllServersApplyToStateMachineTests()
{
_rules = new Rules();
_settings = new InMemorySettingsBuilder().Build();
_random = new RandomDelay();
_peers = new List <IPeer>();
_log = new InMemoryLog();
_fsm = new Rafty.FiniteStateMachine.InMemoryStateMachine();
_node = new NothingNode();
}
/// <summary>
/// Gets a tableaux from cascade of cards.
/// </summary>
/// <param name="cascade">The cascade to get tableaux from.</param>
/// <param name="rules">The rules to use when determining what makes a tableaux.</param>
/// <returns>
/// A list of linking cards from the top of a cascade
/// </returns>
public static List<Card> GetTableauxFromCascade(Cascade cascade, IRules rules)
{
List<Card> tableaux = new List<Card>();
for (int i = (cascade.Count - 1); i > 0; i--)
{
tableaux.Add(cascade[i]);
if (!rules.DoCardsLinkInCascade(cascade[i], cascade[i - 1]))
break;
}
tableaux.Reverse();
return tableaux;
}
public BratController()
{
rules = RulesManager.CreateByEntity<BratEntity, int>();
}
public VeiculoController()
{
rules = RulesManager.CreateByEntity<VeiculoEntity, int>();
}
public TestemunhaController()
{
rules = RulesManager.CreateByEntity<TestemunhaEntity, int>();
}
public static void SetRulesManagerInterface(IRules rules)
{
_rulesManager = rules;
}
public PolicialController()
{
rules = RulesManager.CreateByEntity<PolicialEntity, string>();
}
/// <summary>
/// Initializes a new instance of the <see cref="Game"/> class.
/// </summary>
/// <param name="rules">The rules.</param>
public Game(IRules rules)
{
_states = new Stack<State>();
_rules = rules;
InitializeGame();
}
public static void SetRulesManagerInterface(IRules CustomRules)
{
_rulesManager = CustomRules;
}
public VitimaController()
{
rules = RulesManager.CreateByEntity<VitimaEntity, int>();
}
