🎮 Playing with C: Rectangles Game

A fun exploration of C programming through rectangle manipulation with physics! What started as a university assignment evolved into a comprehensive demonstration of modular programming, physics simulation, and professional development practices.

🌟 Features

• 🔄 Physics Engine: Automatic gravity system with realistic falling behavior
• 🎲 Random IDs: Each rectangle gets a unique random identifier (0-9)
• 🔍 Collision Detection: Advanced collision detection for overlaps and lateral contacts
• 🎨 Visual Display: ASCII-based graphical representation with filled interiors
• ⚡ Real-time Manipulation: Create, move, and delete rectangles with instant feedback
• 🧪 Unit Testing: Comprehensive test suite with 100% function coverage
• 🏗️ Modular Architecture: Clean separation of concerns across multiple modules
• 📏 Boundary Validation: Robust input validation and error handling

🚀 Quick Start

Prerequisites

• GCC compiler (C99 standard or later)
• Unix-like system (Linux, macOS) or Windows with MinGW

Building & Running

# Clone the repository
git clone https://github.com/yourusername/playingwith_C_rectanglesgame.git
cd playingwith_C_rectanglesgame

# Build the project
make

# Run the program
make run

# Run unit tests
make test

🏗️ Architecture

The system follows a modular design pattern with clear separation of responsibilities:

📦 Rectangle System
├── 🎮 main.c           # Entry point and program orchestration
├── 🎯 controlo.c       # Core logic: physics, collision detection, CRUD operations
├── 🎨 visualizacao.c   # Display engine and ASCII rendering
├── 🔍 analise.c        # Command parsing and user interaction
├── 🧪 tests.c          # Comprehensive unit test suite
└── 📄 retangulos.h     # Public API definitions and data structures

📋 Module Responsibilities

Module	Purpose	Key Functions
Control	Physics & State Management	add_rectangle(), apply_gravity(), check_collision()
Visualization	Rendering & Display	display_world(), ASCII art generation
Analysis	Command Processing	parse_command(), process_commands()
Testing	Quality Assurance	Unit tests for all core functions

🎮 Usage

Interactive Mode

The program offers three operation modes:

1. 🎯 Demo Mode: Runs predefined test scenarios
2. ⚡ Interactive Mode: Manual command input
3. 🧪 Testing Mode: Automated unit test execution

Commands Reference

Command	Syntax	Description	Example
Create	create x,y+w,h	Creates a rectangle at position (x,y) with width w and height h	create 5,10+8,4
Move Right	moveright x,y+n	Moves rectangle containing point (x,y) right by n positions	moveright 7,12+3
Move Left	moveleft x,y+n	Moves rectangle containing point (x,y) left by n positions	moveleft 15,8+2
Delete	delete x,y	Removes rectangle containing point (x,y)	delete 10,5
Exit	exit	Terminates interactive mode	exit

📐 Coordinate System

• Origin: Bottom-left corner at (1,1)
• Dimensions: 80×25 grid
• Gravity: Downward (toward y=1)
• Bounds: All rectangles must fit within the plane boundaries

🎨 Visual Representation

Rectangles are displayed with ASCII characters:

xxxxxxxxxxxx
x++++5+++++x  ← Border with 'x', interior filled with '+', ID displayed
x++++++++++x
x++++++++++x
xxxxxxxxxxxx

⚙️ Advanced Features

🧪 Unit Testing Framework

The system includes a comprehensive testing suite:

# Run all tests
make test

# Memory leak detection (requires Valgrind)
make memcheck

# Static code analysis (requires cppcheck)
make analyze

Test Coverage:

• ✅ Random ID generation and uniqueness
• ✅ Rectangle location algorithms
• ✅ Collision detection (overlap and lateral)
• ✅ Boundary condition validation
• ✅ Edge cases and error handling

🔧 Build System

Professional Makefile with multiple targets:

make debug     # Debug build with symbols
make release   # Optimized production build
make clean     # Clean build artifacts
make install   # System-wide installation
make help      # Show all available commands

🎯 Physics Engine

• Gravity Simulation: Rectangles automatically fall until they hit the ground or another rectangle
• Collision Prevention: Movement commands are validated to prevent overlapping
• Lateral Contact Detection: System alerts when rectangles are touching side-by-side

🔬 Technical Specifications

• Language: ANSI C (C99 standard)
• Memory Management: Stack-based allocation with bounds checking
• Maximum Rectangles: 10 concurrent rectangles
• ID System: Random integers 0-9 with collision avoidance
• Coordinate Precision: Integer-based positioning
• Performance: O(n²) collision detection, O(n) gravity application

📊 Performance Characteristics

Operation	Time Complexity	Space Complexity
Rectangle Creation	O(n)	O(1)
Movement	O(n)	O(1)
Collision Detection	O(n²)	O(1)
Gravity Application	O(n²)	O(1)
Display Rendering	O(w×h)	O(w×h)

🛠️ Development

Building from Source

# Development build with debugging
make debug

# Run with memory checking
make memcheck

# Generate documentation (requires Doxygen)
make docs

Code Quality

The project maintains high code quality standards:

• Static Analysis: cppcheck integration
• Memory Safety: Valgrind compatibility
• Modular Design: Clear separation of concerns
• Comprehensive Testing: Unit tests for all critical functions
• Documentation: Inline comments and external docs

🤝 Contributing

Contributions are welcome! Please ensure:

1. All unit tests pass (make test)
2. Code follows existing style conventions
3. New features include corresponding tests
4. Memory leaks are avoided (make memcheck)

📝 Example Session

$ make run
Rectangle Manipulation System
=============================

Choose an option:
1 - Run test example
2 - Interactive mode
3 - Run unit tests
Option: 2

Available commands:
- create x,y+l,h
- moveright x,y+p
- moveleft x,y+p
- delete x,y
- exit

Enter command: create 10,5+8,4
Rectangle created successfully (ID: 7)

Current world state:
xxxxxxxxxxxx
x++++7+++++x
x++++++++++x
xxxxxxxxxxxx

🏆 Project Highlights

This project demonstrates:

• ✨ Advanced C Programming: Modular architecture, proper memory management
• 🧪 Test-Driven Development: Comprehensive unit testing framework
• 🎯 Software Engineering: Clean code principles, separation of concerns
• 🎨 User Experience: Intuitive command interface, visual feedback
• 🔧 Professional Tooling: Modern build system, development workflow

📚 Academic Context

Originally developed as part of a Programming Laboratory course assignment, this project showcases professional-level software development practices including modular design, comprehensive testing, and robust error handling.

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

👤 Author

Maria Sarabando
Computer Science Student

---

⭐ Star this repository if you found it helpful!

Built with ❤️ and lots of ☕