From 7ea366116e2cb2dcbcfb2240168cdc2ec54e1afd Mon Sep 17 00:00:00 2001 From: engapantio Date: Wed, 28 Oct 2026 16:09:20 +0100 Subject: [PATCH] Add initial implementation of Math Game with game logic and configuration files --- .editorconfig | 212 +++++++++++++++++ .../MathGame.engapantio.csproj | 10 + MathGame.engapantio/Program.cs | 219 ++++++++++++++++++ 3 files changed, 441 insertions(+) create mode 100644 .editorconfig create mode 100644 MathGame.engapantio/MathGame.engapantio.csproj create mode 100644 MathGame.engapantio/Program.cs diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 00000000..0023a62d --- /dev/null +++ b/.editorconfig @@ -0,0 +1,212 @@ +# editorconfig.org + +# top-most EditorConfig file +root = true + +# Default settings: +# A newline ending every file +# Use 4 spaces as indentation +[*] +insert_final_newline = true +indent_style = space +indent_size = 4 +trim_trailing_whitespace = true + +[project.json] +indent_size = 2 + +# C# and Visual Basic files +[*.{cs,vb}] +charset = utf-8-bom + +# Analyzers +dotnet_analyzer_diagnostic.category-Security.severity = error +dotnet_code_quality.ca1802.api_surface = private, internal +# SYSLIB5001: Type is for evaluation purposes only and is subject to change or removal in future updates. Suppress this diagnostic to proceed. +dotnet_diagnostic.SYSLIB5001.severity = suggestion + +# Miscellaneous style rules +dotnet_sort_system_directives_first = true +dotnet_style_predefined_type_for_locals_parameters_members = true:suggestion +dotnet_style_predefined_type_for_member_access = true:suggestion + +# avoid this. unless absolutely necessary +dotnet_style_qualification_for_field = false:suggestion +dotnet_style_qualification_for_property = false:suggestion +dotnet_style_qualification_for_method = false:suggestion +dotnet_style_qualification_for_event = false:suggestion + +# name all constant fields using PascalCase +dotnet_naming_rule.constant_fields_should_be_pascal_case.severity = suggestion +dotnet_naming_rule.constant_fields_should_be_pascal_case.symbols = constant_fields +dotnet_naming_rule.constant_fields_should_be_pascal_case.style = pascal_case_style +dotnet_naming_symbols.constant_fields.applicable_kinds = field +dotnet_naming_symbols.constant_fields.required_modifiers = const +dotnet_naming_style.pascal_case_style.capitalization = pascal_case + +# static fields should have s_ prefix +dotnet_naming_rule.static_fields_should_have_prefix.severity = suggestion +dotnet_naming_rule.static_fields_should_have_prefix.symbols = static_fields +dotnet_naming_rule.static_fields_should_have_prefix.style = static_prefix_style +dotnet_naming_symbols.static_fields.applicable_kinds = field +dotnet_naming_symbols.static_fields.required_modifiers = static +dotnet_naming_symbols.static_fields.applicable_accessibilities = private, internal, private_protected +dotnet_naming_style.static_prefix_style.required_prefix = s_ +dotnet_naming_style.static_prefix_style.capitalization = camel_case + +# internal and private fields should be _camelCase +dotnet_naming_rule.camel_case_for_private_internal_fields.severity = suggestion +dotnet_naming_rule.camel_case_for_private_internal_fields.symbols = private_internal_fields +dotnet_naming_rule.camel_case_for_private_internal_fields.style = camel_case_underscore_style +dotnet_naming_symbols.private_internal_fields.applicable_kinds = field +dotnet_naming_symbols.private_internal_fields.applicable_accessibilities = private, internal +dotnet_naming_style.camel_case_underscore_style.required_prefix = _ +dotnet_naming_style.camel_case_underscore_style.capitalization = camel_case + +# Code quality +dotnet_style_readonly_field = true:suggestion +dotnet_code_quality_unused_parameters = non_public:suggestion + +# Expression-level preferences +dotnet_style_object_initializer = true:suggestion +dotnet_style_collection_initializer = true:suggestion +dotnet_style_explicit_tuple_names = true:suggestion +dotnet_style_coalesce_expression = true:suggestion +dotnet_style_null_propagation = true:suggestion +dotnet_style_prefer_is_null_check_over_reference_equality_method = true:suggestion +dotnet_style_prefer_inferred_tuple_names = true:suggestion +dotnet_style_prefer_inferred_anonymous_type_member_names = true:suggestion +dotnet_style_prefer_auto_properties = true:suggestion +dotnet_style_prefer_conditional_expression_over_assignment = true:refactoring +dotnet_style_prefer_conditional_expression_over_return = true:refactoring + +# CA2208: Instantiate argument exceptions correctly +dotnet_diagnostic.CA2208.severity = error + +# C# files +[*.cs] +# New line preferences +csharp_new_line_before_open_brace = all +csharp_new_line_before_else = true +csharp_new_line_before_catch = true +csharp_new_line_before_finally = true +csharp_new_line_before_members_in_object_initializers = true +csharp_new_line_before_members_in_anonymous_types = true +csharp_new_line_between_query_expression_clauses = true + +# Indentation preferences +csharp_indent_block_contents = true +csharp_indent_braces = false +csharp_indent_case_contents = true +csharp_indent_case_contents_when_block = true +csharp_indent_switch_labels = true +csharp_indent_labels = one_less_than_current + +# Modifier preferences +csharp_preferred_modifier_order = public,private,protected,internal,static,extern,new,virtual,abstract,sealed,override,readonly,unsafe,volatile,async:suggestion + +# Code style defaults +csharp_using_directive_placement = outside_namespace:suggestion +csharp_prefer_braces = true:refactoring +csharp_preserve_single_line_blocks = true:none +csharp_preserve_single_line_statements = false:none +csharp_prefer_static_local_function = true:suggestion +csharp_prefer_simple_using_statement = false:none +csharp_style_prefer_switch_expression = true:suggestion + +# Expression-bodied members +csharp_style_expression_bodied_methods = true:refactoring +csharp_style_expression_bodied_constructors = true:refactoring +csharp_style_expression_bodied_operators = true:refactoring +csharp_style_expression_bodied_properties = true:refactoring +csharp_style_expression_bodied_indexers = true:refactoring +csharp_style_expression_bodied_accessors = true:refactoring +csharp_style_expression_bodied_lambdas = true:refactoring +csharp_style_expression_bodied_local_functions = true:refactoring + +# Pattern matching +csharp_style_pattern_matching_over_is_with_cast_check = true:suggestion +csharp_style_pattern_matching_over_as_with_null_check = true:suggestion +csharp_style_inlined_variable_declaration = true:suggestion + +# Expression-level preferences +csharp_prefer_simple_default_expression = true:suggestion + +# Null checking preferences +csharp_style_throw_expression = true:suggestion +csharp_style_conditional_delegate_call = true:suggestion + +# Other features +csharp_style_prefer_index_operator = false:none +csharp_style_prefer_range_operator = false:none +csharp_style_pattern_local_over_anonymous_function = false:none + +# Space preferences +csharp_space_after_cast = false +csharp_space_after_colon_in_inheritance_clause = true +csharp_space_after_comma = true +csharp_space_after_dot = false +csharp_space_after_keywords_in_control_flow_statements = true +csharp_space_after_semicolon_in_for_statement = true +csharp_space_around_binary_operators = before_and_after +csharp_space_around_declaration_statements = do_not_ignore +csharp_space_before_colon_in_inheritance_clause = true +csharp_space_before_comma = false +csharp_space_before_dot = false +csharp_space_before_open_square_brackets = false +csharp_space_before_semicolon_in_for_statement = false +csharp_space_between_empty_square_brackets = false +csharp_space_between_method_call_empty_parameter_list_parentheses = false +csharp_space_between_method_call_name_and_opening_parenthesis = false +csharp_space_between_method_call_parameter_list_parentheses = false +csharp_space_between_method_declaration_empty_parameter_list_parentheses = false +csharp_space_between_method_declaration_name_and_open_parenthesis = false +csharp_space_between_method_declaration_parameter_list_parentheses = false +csharp_space_between_parentheses = false +csharp_space_between_square_brackets = false + +# Namespace preference +csharp_style_namespace_declarations = file_scoped:suggestion + +# Types: use keywords instead of BCL types, and permit var only when the type is clear +csharp_style_var_for_built_in_types = false:suggestion +csharp_style_var_when_type_is_apparent = false:none +csharp_style_var_elsewhere = false:suggestion + +# Visual Basic files +[*.vb] +# Modifier preferences +visual_basic_preferred_modifier_order = Partial,Default,Private,Protected,Public,Friend,NotOverridable,Overridable,MustOverride,Overloads,Overrides,MustInherit,NotInheritable,Static,Shared,Shadows,ReadOnly,WriteOnly,Dim,Const,WithEvents,Widening,Narrowing,Custom,Async:suggestion + +# C++ Files +[*.{cpp,h,in}] +curly_bracket_next_line = true +indent_brace_style = Allman + +# Xml project files +[*.{csproj,vbproj,vcxproj,vcxproj.filters,proj,nativeproj,locproj}] +indent_size = 2 + +# Xml build files +[*.builds] +indent_size = 2 + +# Xml files +[*.{xml,stylecop,resx,ruleset}] +indent_size = 2 + +# Xml config files +[*.{props,targets,config,nuspec}] +indent_size = 2 + +# Shell scripts +[*.sh] +end_of_line = lf + +[*.{cmd, bat}] +end_of_line = crlf + +# Markdown files +[*.md] + # Double trailing spaces can be used for BR tags, and other instances are enforced by Markdownlint +trim_trailing_whitespace = false \ No newline at end of file diff --git a/MathGame.engapantio/MathGame.engapantio.csproj b/MathGame.engapantio/MathGame.engapantio.csproj new file mode 100644 index 00000000..2150e379 --- /dev/null +++ b/MathGame.engapantio/MathGame.engapantio.csproj @@ -0,0 +1,10 @@ + + + + Exe + net8.0 + enable + enable + + + diff --git a/MathGame.engapantio/Program.cs b/MathGame.engapantio/Program.cs new file mode 100644 index 00000000..9f4a54bf --- /dev/null +++ b/MathGame.engapantio/Program.cs @@ -0,0 +1,219 @@ +using System.Diagnostics; + +List gameHistory = []; +var random = new Random(); + +while (true) +{ + Console.WriteLine("Math Game"); + Console.WriteLine("1. Addition"); + Console.WriteLine("2. Subtraction"); + Console.WriteLine("3. Multiplication"); + Console.WriteLine("4. Division"); + Console.WriteLine("5. Random Game"); + Console.WriteLine("6. History"); + Console.WriteLine("0. Exit"); + Console.Write("Choose an option: "); + + switch (Console.ReadLine()) + { + case "1": + PlayGame(ArithmeticOperation.Addition, gameHistory, random); + break; + case "2": + PlayGame(ArithmeticOperation.Subtraction, gameHistory, random); + break; + case "3": + PlayGame(ArithmeticOperation.Multiplication, gameHistory, random); + break; + case "4": + PlayGame(ArithmeticOperation.Division, gameHistory, random); + break; + case "5": + PlayGame(null, gameHistory, random); + break; + case "6": + ShowHistory(gameHistory); + break; + case "0": + return; + default: + Console.WriteLine("Please choose a valid menu option."); + break; + } + + Console.WriteLine(); +} + +static void PlayGame( + ArithmeticOperation? selectedOperation, + List gameHistory, + Random random) +{ + DifficultyLevel difficulty = ReadDifficulty(); + int questionCount = ReadQuestionCount(); + int maximumOperand = difficulty switch + { + DifficultyLevel.Easy => 10, + DifficultyLevel.Medium => 50, + DifficultyLevel.Hard => 100, + _ => throw new InvalidOperationException("Unknown difficulty level.") + }; + var score = 0; + Stopwatch stopwatch = Stopwatch.StartNew(); + + for (var questionNumber = 1; questionNumber <= questionCount; questionNumber++) + { + ArithmeticOperation operation = selectedOperation ?? (ArithmeticOperation)random.Next(0, 4); + MathQuestion question = CreateQuestion(operation, maximumOperand, random); + + Console.WriteLine($"Question {questionNumber}/{questionCount}: {question.Prompt}"); + Console.Write("Your answer: "); + string? answerText = Console.ReadLine(); + bool isValidAnswer = int.TryParse(answerText, out int answer); + + if (isValidAnswer && (answer == question.CorrectAnswer)) + { + score++; + Console.WriteLine("Correct!"); + } + else if (isValidAnswer) + { + Console.WriteLine($"Incorrect. The answer was {question.CorrectAnswer}."); + } + else + { + Console.WriteLine($"Invalid answer. The answer was {question.CorrectAnswer}."); + } + } + + stopwatch.Stop(); + string mode = selectedOperation?.ToString() ?? "Random"; + var result = new GameResult(mode, difficulty, score, questionCount, stopwatch.Elapsed); + gameHistory.Add(result); + + Console.WriteLine($"Game complete: {score}/{questionCount} correct."); + Console.WriteLine($"Elapsed time: {stopwatch.Elapsed.TotalSeconds:F1} seconds."); +} + +static DifficultyLevel ReadDifficulty() +{ + while (true) + { + Console.WriteLine("Choose difficulty: 1. Easy (0-10), 2. Medium (0-50), 3. Hard (0-100)"); + Console.Write("Difficulty: "); + + switch (Console.ReadLine()) + { + case "1": + return DifficultyLevel.Easy; + case "2": + return DifficultyLevel.Medium; + case "3": + return DifficultyLevel.Hard; + default: + Console.WriteLine("Please choose 1, 2, or 3."); + break; + } + } +} + +static int ReadQuestionCount() +{ + while (true) + { + Console.Write("Number of questions (minimum 5): "); + if (int.TryParse(Console.ReadLine(), out int questionCount) && (questionCount >= 5)) + { + return questionCount; + } + + Console.WriteLine("Enter a whole number of at least 5."); + } +} + +static MathQuestion CreateQuestion( + ArithmeticOperation operation, + int maximumOperand, + Random random) +{ + int firstOperand = random.Next(0, maximumOperand + 1); + int secondOperand = random.Next(0, maximumOperand + 1); + + return operation switch + { + ArithmeticOperation.Addition => new MathQuestion( + $"{firstOperand} + {secondOperand} = ?", + firstOperand + secondOperand), + ArithmeticOperation.Subtraction => CreateSubtractionQuestion(firstOperand, secondOperand), + ArithmeticOperation.Multiplication => new MathQuestion( + $"{firstOperand} x {secondOperand} = ?", + firstOperand * secondOperand), + ArithmeticOperation.Division => CreateDivisionQuestion(maximumOperand, random), + _ => throw new InvalidOperationException("Unknown arithmetic operation.") + }; +} + +static MathQuestion CreateSubtractionQuestion(int firstOperand, int secondOperand) +{ + int largerOperand = Math.Max(firstOperand, secondOperand); + int smallerOperand = Math.Min(firstOperand, secondOperand); + return new MathQuestion( + $"{largerOperand} - {smallerOperand} = ?", + largerOperand - smallerOperand); +} + +static MathQuestion CreateDivisionQuestion(int maximumOperand, Random random) +{ + int dividend = random.Next(0, maximumOperand + 1); + int[] possibleDivisors = dividend == 0 + ? Enumerable.Range(1, maximumOperand).ToArray() + : Enumerable.Range(1, Math.Min(dividend, maximumOperand)) + .Where(divisor => dividend % divisor == 0) + .ToArray(); + int divisor = possibleDivisors[random.Next(possibleDivisors.Length)]; + + return new MathQuestion( + $"{dividend} / {divisor} = ?", + dividend / divisor); +} + +static void ShowHistory(List gameHistory) +{ + if (gameHistory.Count == 0) + { + Console.WriteLine("No games have been completed yet."); + return; + } + + Console.WriteLine("Game history:"); + for (var index = 0; index < gameHistory.Count; index++) + { + GameResult result = gameHistory[index]; + Console.WriteLine($"{index + 1}. {result.Mode}, {result.Difficulty}: {result.Score}/{result.QuestionCount}, {result.Elapsed.TotalSeconds:F1} seconds"); + } +} + +enum ArithmeticOperation +{ + Addition, + Subtraction, + Multiplication, + Division +} + +enum DifficultyLevel +{ + Easy, + Medium, + Hard +} + +record MathQuestion(string Prompt, int CorrectAnswer); + +record GameResult( + string Mode, + DifficultyLevel Difficulty, + int Score, + int QuestionCount, + TimeSpan Elapsed);