//////////////////// // // Name: Mars Rover // Author: Shadow // Version: 1.2.0 // Date: 15.12.2018 // Description: Submission for the Mars Rover contest // from Sololearn (see comments). // I had to cut out the input checking // through regex, but it should work // properly even without it. // // Planned: // // Input: The list of commands you can give to // the rover. // The map generation is randomized, which // means certain commands such as RCK // are a gamble on SL since you cannot // certainly say whether you stand on one // or not. // So if you don't want to run the code // in a proper IDE, just try some random // combinations of commands. // List of currently supported commands: // ! MOV F n // => moves the rover n steps forward // ! MOV B n // => moves the rover n steps backwards // ! TRN L // => turns the rover anticlockwise by 45deg // ! TRN R // => turns the rover clockwise by 45deg // ! RCK // => attempt to pick up a rock // ! RLS // => release the top rock from the container // ! CLS // => empty the rock container // ! ANS // => perform an analysis of the top rock // ! PIC // => take a picture of the area // ! DEL // => delete the oldest picture // ! PRT // => print the latest picture // ! LOG // => print the command log // ! EXT // => shut the rover down (ends input) // // Output: Output of the Command Processing Module. // Symbols on the map / picture: // @ => Rock // O => Obstacle // R => Rover // //////////////////// #include #include #include #include #include #include #include #include #include #include #include #include #define dummy std::cin >> //////////////////////////////////////// // // // Constants // // --------- // // Constant values that are necessary // // throughout the program. // // // //////////////////////////////////////// /* Number of cells in a row in the output field */ constexpr uint16_t rowCells { 19 }; /* Number of cells in a column in the output field */ constexpr uint16_t columnCells { 7 }; /* Maximum size of the robot's container for rocks */ constexpr uint16_t rockCapacity { 5 }; /* Maximum size of the robot's container for images */ constexpr uint16_t imageCapacity { 10 }; /* Maximum size of the robot's command log */ constexpr uint16_t logCapacity { 20 }; /* The chance for a single cell to be filled up */ constexpr uint16_t mapDensity { 40 }; /* The symbols for different objects on the map */ enum class OBJECT_TYPES : uint8_t { ROCK = 64, // @ OBSTACLE = 79, // O ROVER = 82 // R }; enum class OBJECT_PROBABILITY : uint16_t { OBSTACLE = 5, ROCK = 100 }; //////////////////////////////////////// // // // Declarations // // ------------ // // Forward declarations and using // // directives for later use in the // // program. // // // //////////////////////////////////////// class Object; class Command; class RoverCommand; class Rover; using std::chrono::system_clock; using Surface = std::vector< std::unique_ptr< Object > >; //////////////////////////////////////// // // // Functions // // ------------ // // Unrelated global functions. // // // //////////////////////////////////////// void drawBorder( const char c = '-' ) noexcept { for (uint16_t i {0}; i < (rowCells << 1) + 1; ++i) { std::cout << c; } std::cout << "\n"; } void drawBorder( const uint16_t width, const char c = '-' ) noexcept { for (uint16_t i {0}; i < width; ++i) { std::cout << c; } std::cout << "\n"; } //////////////////////////////////////// // // // Randomness Functionality // // ------------------------ // // Objects and functions to // // implement randomness into the // // program. // // // //////////////////////////////////////// /* Generator to produce random numbers */ std::mt19937 mersenneGenerator ( system_clock::now().time_since_epoch().count() ); /* Function that produces a random integer value. * The parameter 'min' is included into the range. * The parameter 'max' is included into the range. */ int randomInt( const int min, const int max ) { std::uniform_int_distribution distribution { min, max }; return distribution( mersenneGenerator ); } //////////////////////////////////////// // // // Exceptions // // ---------- // // A list of classes for all // // different kinds of exceptions used // // in the program. // // // //////////////////////////////////////// class BadAllocException : public std::runtime_error { public: BadAllocException() noexcept : std::runtime_error{ "[ERROR] Unable to allocate enough memory." } {} }; //////////////////////////////////////// // // // Memory Management // // ----------------- // // An incredibly basic allocator // // class that handles memory related // // tasks in the application. // // // //////////////////////////////////////// template < class T > class DefaultAllocator { private: using value_type = T; using pointer = T*; using reference = T&; using const_pointer = const T*; using const_reference = const T&; using size_type = std::size_t; public: DefaultAllocator() noexcept = default; DefaultAllocator( const DefaultAllocator& ) noexcept = default; ~DefaultAllocator() = default; pointer address( reference ) const noexcept; const_pointer address( const_reference ) const noexcept; pointer allocate(); void deallocate( pointer ) noexcept; }; template < class T > T* DefaultAllocator::address( T& x ) const noexcept { return &x; } template < class T > const T* DefaultAllocator::address( const T& x ) const noexcept { return &x; } template < class T > T* DefaultAllocator::allocate() { T* ptr = static_cast( ::operator new ( sizeof( T ) ) ); if ( !ptr ) { throw BadAllocException(); } return ptr; } template < class T > void DefaultAllocator::deallocate( T* ptr) noexcept { if ( ptr ) { ::delete ( ptr ); } } template < class T > class DefaultAllocator< T[] > { private: using value_type = T; using pointer = T*; using reference = T&; using const_pointer = const T*; using const_reference = const T&; using size_type = std::size_t; public: DefaultAllocator() noexcept = default; DefaultAllocator( const DefaultAllocator& ) noexcept = default; ~DefaultAllocator() = default; pointer address( reference ) const noexcept; const_pointer address( const_reference ) const noexcept; pointer allocate( const size_type ); void deallocate( pointer ) noexcept; }; template < class T > T* DefaultAllocator< T[] >::address( T& x ) const noexcept { return &x; } template < class T > const T* DefaultAllocator< T[] >::address( const T& x ) const noexcept { return &x; } template < class T > T* DefaultAllocator< T[] >::allocate( const std::size_t n ) { T* ptr = static_cast( ::operator new[] ( n * sizeof( T ) ) ); if ( !ptr ) { throw BadAllocException(); } return ptr; } template < class T > void DefaultAllocator< T[] >::deallocate( T* ptr) noexcept { if ( ptr ) { ::delete[] ( ptr ); } } //////////////////////////////////////// // // // Abstract Factories // // --------------- // // Base classes for all abstract // // factories in the application. // // // //////////////////////////////////////// struct AbstractObjectFactory { virtual std::unique_ptr< Object > create( const int16_t, const int16_t ) const = 0; }; struct AbstractCommandFactory { std::string mCommand; AbstractCommandFactory( const std::string& command ) : mCommand{ command } {} virtual std::unique_ptr< RoverCommand > create( Rover& ) const = 0; }; //////////////////////////////////////// // // // Object Class // // ------------ // // Base class for all objects on the // // map. All objects share a pair of // // coordinates aswell as an // // implementation of a draw() method, // // which is implemented inside the // // derived classes. // // // //////////////////////////////////////// struct Coordinates { int16_t x; int16_t y; Coordinates( const int16_t x, const int16_t y ) noexcept : x{ x }, y{ y } {} }; class Object { protected: Coordinates mCoordinates; OBJECT_TYPES mObjectType; Object( const int16_t x, const int16_t y, const OBJECT_TYPES type ) noexcept : mCoordinates{ x, y }, mObjectType{ type } {} Object( const Coordinates& point, const OBJECT_TYPES type ) noexcept : mCoordinates{ point }, mObjectType{ type } {} public: inline void draw() const noexcept { std::cout << static_cast< uint8_t >( mObjectType ); } inline int16_t getX() const { return mCoordinates.x; } inline int16_t getY() const { return mCoordinates.y; } inline OBJECT_TYPES getObjectType() const { return mObjectType; } }; //////////////////////////////////////// // // // Rocks // // ----- // // A class simulating rocks like they // // could possibly be picked up by the // // robot. Subclasses implement // // different kinds of rocks. // // The factory produces a random kind // // of rock. // // // //////////////////////////////////////// class Rock : public Object { private: std::string mName; std::string mColour; std::vector< std::string > mElements; std::vector< std::string > mCharacteristics; protected: Rock ( const int16_t x, const int16_t y, const std::string& name, const std::string& colour, const std::vector< std::string >& elements, const std::vector< std::string >& properties ) : Object( x, y, OBJECT_TYPES::ROCK ), mName{ name }, mColour{ colour }, mElements{ elements }, mCharacteristics{ properties } {} public: friend std::ostream& operator << ( std::ostream&, const Rock& ); }; std::ostream& operator << ( std::ostream& os, const Rock& rock ) { os << "Name: " << rock.mName << "\nColour: " << rock.mColour << "\nElements: "; for (const std::string& s : rock.mElements) { os << "[" << s << "] "; } os << "\nCharacteristics: "; for (const std::string& s : rock.mCharacteristics) { os << "[" << s << "] "; } os << "\n"; return os; } class Sandstone : public Rock { public: Sandstone( const int16_t x, const int16_t y) : Rock ( x, y, "Sandstone", "Brown / Red", { "Feldspar", "Quartz" }, { "Layered", "Porous" } ) {} }; struct SandstoneFactory : public AbstractObjectFactory { std::unique_ptr< Object > create( const int16_t x, const int16_t y ) const override { return std::make_unique( x, y ); } }; class Limestone : public Rock { public: Limestone( const int16_t x, const int16_t y) : Rock ( x, y, "Limestone", "White / Yellow", { "Calcite" }, { "Granulitic", "Layered", "Porous" } ) {} }; struct LimestoneFactory : public AbstractObjectFactory { std::unique_ptr< Object > create( const int16_t x, const int16_t y ) const override { return std::make_unique( x, y ); } }; class Chalkstone : public Rock { public: Chalkstone( const int16_t x, const int16_t y) : Rock ( x, y, "Chalkstone", "White / Red", { "Calcite" }, { "Granulitic", "Powdery", "Soft" } ) {} }; struct ChalkstoneFactory : public AbstractObjectFactory { std::unique_ptr< Object > create( const int16_t x, const int16_t y ) const override { return std::make_unique( x, y ); } }; class Granite : public Rock { public: Granite( const int16_t x, const int16_t y) : Rock ( x, y, "Granite", "Grey / Yellow / Brown / Red", { "Feldspar", "Glimmer", "Quartz" }, { "Coarse" } ) {} }; struct GraniteFactory : public AbstractObjectFactory { std::unique_ptr< Object > create( const int16_t x, const int16_t y ) const override { return std::make_unique( x, y ); } }; class Basalt : public Rock { public: Basalt( const int16_t x, const int16_t y) : Rock ( x, y, "Basalt", "Grey / Black", { "Feldspar" }, { "Prism Structure", "Thick" } ) {} }; struct BasaltFactory : public AbstractObjectFactory { std::unique_ptr< Object > create( const int16_t x, const int16_t y ) const override { return std::make_unique( x, y ); } }; class Pumice : public Rock { public: Pumice( const int16_t x, const int16_t y) : Rock ( x, y, "Pumice", "Yellow / Grey", { "Magma" }, { "Amorphous", "Porous" } ) {} }; struct PumiceFactory : public AbstractObjectFactory { std::unique_ptr< Object > create( const int16_t x, const int16_t y ) const override { return std::make_unique( x, y ); } }; class ForbiddenStone : public Rock { public: ForbiddenStone( const int16_t x, const int16_t y) : Rock ( x, y, "Stone of the Wise", "Red", { "Humans" }, { "Powerful" } ) {} }; struct ForbiddenStoneFactory : public AbstractObjectFactory { std::unique_ptr< Object > create( const int16_t x, const int16_t y ) const override { return std::make_unique( x, y ); } }; struct RockFactory : public AbstractObjectFactory { private: static std::vector< std::shared_ptr< AbstractObjectFactory > > mFactories; public: RockFactory() = default; std::unique_ptr< Object > create( const int16_t, const int16_t ) const override; }; std::vector< std::shared_ptr< AbstractObjectFactory > > RockFactory::mFactories = { std::make_shared< SandstoneFactory >(), std::make_shared< LimestoneFactory >(), std::make_shared< ChalkstoneFactory >(), std::make_shared< GraniteFactory >(), std::make_shared< BasaltFactory >(), std::make_shared< PumiceFactory >(), std::make_shared< ForbiddenStoneFactory >() }; std::unique_ptr< Object > RockFactory::create( const int16_t x, const int16_t y ) const { return mFactories[ randomInt(0, mFactories.size() - 1) ]->create( x, y ); } //////////////////////////////////////// // // // Obstacles // // --------- // // Obstacles that block the robot's // // movement. // // // //////////////////////////////////////// class Obstacle : public Object { public: Obstacle( const int16_t x, const int16_t y ) : Object( x, y, OBJECT_TYPES::OBSTACLE ) {} }; struct ObstacleFactory : public AbstractObjectFactory { std::unique_ptr< Object > create( const int16_t x, const int16_t y ) const override { return std::make_unique( x, y ); } }; //////////////////////////////////////// // // // Object Factory // // -------------- // // Factory to produce a random object // // based on constant probabilities. // // // //////////////////////////////////////// class Factory { private: uint16_t mProbability; std::shared_ptr< AbstractObjectFactory > mFactory; public: Factory( const uint16_t probability, std::shared_ptr< AbstractObjectFactory >&& ptr ) : mProbability{ probability }, mFactory{ std::move( ptr ) } {} std::unique_ptr< Object > create( const int16_t x, const int16_t y ) const { return mFactory->create( x, y ); } inline uint16_t getProbability() const { return mProbability; } }; class ObjectFactory : public AbstractObjectFactory { private: static std::vector< Factory > mFactories; public: ObjectFactory() = default; std::unique_ptr< Object > create( const int16_t, const int16_t ) const override; }; std::vector< Factory > ObjectFactory::mFactories = { Factory( static_cast( OBJECT_PROBABILITY::OBSTACLE ), std::make_shared< ObstacleFactory >() ), Factory( static_cast( OBJECT_PROBABILITY::ROCK ), std::make_shared< RockFactory >() ) }; std::unique_ptr< Object > ObjectFactory::create( const int16_t x, const int16_t y ) const { const uint16_t rndNumber = randomInt( 0, 100 ); for ( const Factory& factory : mFactories ) { if ( rndNumber <= factory.getProbability() ) { return factory.create( x, y ); } } return nullptr; } //////////////////////////////////////// // // // Surface // // ------- // // Some functions regarding the // // surface. // // // //////////////////////////////////////// namespace Mars { void initialize( Surface& surface ) noexcept { ObjectFactory tempFactory; for ( uint16_t i {0}; i < rowCells; ++i ) { for ( uint16_t j {0}; j < columnCells; ++j ) { if ( randomInt( 0, 100 ) <= mapDensity ) { surface.push_back( tempFactory.create( i, j ) ); } } } } void render( const Surface& objects ) noexcept { drawBorder(); for (uint16_t i {0}; i < columnCells; ++i) { std::cout << "|"; for (uint16_t j {0}; j < rowCells; ++j) { bool cell_isUsed = false; for (const std::unique_ptr< Object > &obj : objects) { if ( obj->getX() == j && obj->getY() == i ) { cell_isUsed = true; obj->draw(); break; } } std::cout << ( cell_isUsed ? "" : " " ) << "|"; } std::cout << "\n"; drawBorder(); } } } //////////////////////////////////////// // // // Fixed Container // // -------------- // // The underlying container for both // // the robot's rock and image // // container. The container is a mix // // of array and vector to allow for // // dynamic addition and removal up to // // a specified limit without any // // additional allocation of memory // // except when the container is // // initialized for the first time, // // however, the functionality is // // greatly limited to stack-like // // behaviour. // // // //////////////////////////////////////// template < class T, class N, class Allocator = DefaultAllocator< T[] > > class FixedContainer { private: using value_type = T; using allocator_type = Allocator; using pointer = T*; using reference = T&; using const_pointer = const T*; using const_reference = const T&; using size_type = N; allocator_type mAllocator; pointer mData; size_type mSize; size_type mCapacity; public: FixedContainer(); FixedContainer( const allocator_type& ); FixedContainer( const size_type, const allocator_type& = allocator_type() ); FixedContainer( const size_type, const value_type&, const allocator_type& = allocator_type() ); FixedContainer( std::initializer_list &, const allocator_type& = allocator_type() ); virtual ~FixedContainer(); bool empty() const noexcept; size_type size() const noexcept; size_type capacity() const noexcept; reference back() noexcept; const_reference back() const noexcept; void push( const value_type& ) noexcept; void pop() noexcept; void clear() noexcept; }; template < class T, class N, class Allocator > FixedContainer::FixedContainer() : mAllocator{ DefaultAllocator() }, mSize{ 0 }, mCapacity{ 0 } { mData = mAllocator.allocate( mSize ); } template < class T, class N, class Allocator > FixedContainer::FixedContainer( const Allocator& allocator ) : mAllocator{ allocator }, mSize{ 0 }, mCapacity{ 0 } { mData = mAllocator.allocate( mCapacity ); } template < class T, class N, class Allocator > FixedContainer::FixedContainer( const N cap, const Allocator& allocator ) : mAllocator{ allocator }, mSize{ 0 }, mCapacity{ cap } { mData = mAllocator.allocate( mCapacity ); } template < class T, class N, class Allocator > FixedContainer::FixedContainer( const N cap, const T& value, const Allocator& allocator ) : mAllocator{ allocator }, mSize{ cap }, mCapacity{ cap } { mData = mAllocator.allocate( mCapacity ); for (N index {0}; index < mSize; ++index) { *(mData + index) = value; } } template < class T, class N, class Allocator > FixedContainer::FixedContainer( std::initializer_list& iList, const Allocator& allocator ) : mAllocator{ allocator }, mSize{ 0 }, mCapacity{ iList.size() } { mData = mAllocator.allocate( mCapacity ); for (auto it = iList.begin(); it != iList.end(); ++it) { push( *it ); } } template < class T, class N, class Allocator > FixedContainer::~FixedContainer() { clear(); mAllocator.deallocate( mData ); } template < class T, class N, class Allocator > bool FixedContainer::empty() const noexcept { return !mSize; } template < class T, class N, class Allocator > N FixedContainer::size() const noexcept { return mSize; } template < class T, class N, class Allocator > N FixedContainer::capacity() const noexcept { return mCapacity; } template < class T, class N, class Allocator > T& FixedContainer::back() noexcept { return *(mData + mSize - 1); } template < class T, class N, class Allocator > const T& FixedContainer::back() const noexcept { return *(mData + mSize - 1); } template < class T, class N, class Allocator > void FixedContainer::push( const T& value ) noexcept { if ( mSize < mCapacity ) { *( mData + mSize ) = value; ++mSize; } } template < class T, class N, class Allocator > void FixedContainer::pop() noexcept { if ( mSize > 0 ) { --mSize; } } template < class T, class N, class Allocator > void FixedContainer::clear() noexcept { while ( mSize ) { pop(); } } //////////////////////////////////////// // // // Rock Container // // -------------- // // Specification of the generic // // FixedContainer template for // // objects of class Rock. The public // // member functions are reused, only // // the construction process is // // narrowed. // // // //////////////////////////////////////// class RockContainer : public FixedContainer< Rock, uint16_t > { public: RockContainer() : FixedContainer( rockCapacity ) {} }; //////////////////////////////////////// // // // Picture // // ------- // // Class to simulate a picture, which // // consists of a two-dimensional char // // array and is constructed from a // // surface object as reference. // // // //////////////////////////////////////// class Picture { private: std::unique_ptr< std::unique_ptr< char[] >[] > mPixels; uint16_t mWidth; uint16_t mHeight; public: Picture( const Surface&, const uint16_t = rowCells, const uint16_t = columnCells ); Picture( const Picture& ); void print() const; }; Picture::Picture( const Surface& surface, const uint16_t width, const uint16_t height ) : mPixels{ new std::unique_ptr< char[] >[ height ] }, mWidth{ width }, mHeight{ height } { for ( uint16_t i {0}; i < mHeight; ++i ) { mPixels[i] = std::unique_ptr< char[] >( new char[ mWidth ] ); for ( uint16_t j {0}; j < mWidth; ++j ) { mPixels[i][j] = ' '; } } for ( auto it = surface.cbegin(); it != surface.cend(); ++it ) { mPixels[ (*it)->getY() ][ (*it)->getX() ] = static_cast< char >( (*it)->getObjectType() ); } } Picture::Picture( const Picture& image ) : mPixels{ new std::unique_ptr< char[] >[ image.mHeight ] }, mWidth{ image.mWidth }, mHeight{ image.mHeight } { for ( uint16_t i {0}; i < mHeight; ++i ) { mPixels[i] = std::unique_ptr< char[] >( new char[ image.mWidth ] ); for ( uint16_t j {0}; j < mWidth; ++j ) { mPixels[i][j] = image.mPixels[i][j]; } } } void Picture::print() const { drawBorder( mWidth, '=' ); for ( uint16_t i {0}; i < mHeight; ++i ) { for ( uint16_t j {0}; j < mWidth; ++j ) { std::cout << mPixels[i][j]; } std::cout << "\n"; } drawBorder( mWidth, '=' ); } //////////////////////////////////////// // // // Command Interfaces // // ------------------ // // Interfaces of the different // // commands the CPM can send to the // // rover. // // // //////////////////////////////////////// struct Command { virtual void call() const = 0; }; struct RoverCommand : public Command { Rover& mRover; std::string mCommand; RoverCommand( Rover& r, const std::string& s ) : mRover{ r }, mCommand{ s } { std::cout << "Transmitting the signal...\n"; } }; struct MoveCommand : public RoverCommand { enum DIRECTION { FORWARD, BACKWARD } Direction; int16_t distance; MoveCommand( Rover& r, const DIRECTION direction, const int16_t d ) : RoverCommand( r, "MOV" ), Direction{ direction }, distance{ d } { std::cout << "Move signal transmitted!\n" << "Moving the rover " << distance << " unit(s) " << ( Direction == FORWARD ? "forwards" : "backwards" ) << ".\n"; } void call() const override; }; struct TurnCommand : public RoverCommand { enum DIRECTION { LEFT, RIGHT } Direction; TurnCommand( Rover& r, const DIRECTION d ) : RoverCommand( r, "TRN" ), Direction{ d } { std::cout << "Turn signal transmitted!\n" << "The rover has successfully turned " << ( Direction == DIRECTION::LEFT ? "left" : "right" ) << ".\n"; } void call() const override; }; struct CollectCommand : public RoverCommand { CollectCommand( Rover& r ) : RoverCommand( r, "RCK" ) { std::cout << "Collect signal transmitted!\n" << "Searching for a rock...\n"; } void call() const override; }; struct CollectCommandFactory : public AbstractCommandFactory { CollectCommandFactory() : AbstractCommandFactory( "RCK" ) {} std::unique_ptr< RoverCommand > create( Rover& r ) const override { return std::make_unique< CollectCommand >( r ); } }; struct ReleaseCommand : public RoverCommand { ReleaseCommand( Rover& r ) : RoverCommand( r, "RLS" ) { std::cout << "Release signal transmitted!\n"; } void call() const override; }; struct ReleaseCommandFactory : public AbstractCommandFactory { ReleaseCommandFactory() : AbstractCommandFactory( "RLS" ) {} std::unique_ptr< RoverCommand > create( Rover& r ) const override { return std::make_unique< ReleaseCommand >( r ); } }; struct ClearCommand : public RoverCommand { ClearCommand( Rover& r ) : RoverCommand( r, "CLS" ) { std::cout << "Clear signal transmitted!\n"; } void call() const override; }; struct ClearCommandFactory : public AbstractCommandFactory { ClearCommandFactory() : AbstractCommandFactory( "CLS" ) {} std::unique_ptr< RoverCommand > create( Rover& r ) const override { return std::make_unique< ClearCommand >( r ); } }; struct AnalyseCommand : public RoverCommand { AnalyseCommand( Rover& r ) : RoverCommand( r, "ANS" ) { std::cout << "Analyse signal transmitted!\n" << "Beginning the evaluation...\n\n"; } void call() const override; }; struct AnalyseCommandFactory : public AbstractCommandFactory { AnalyseCommandFactory() : AbstractCommandFactory( "ANS" ) {} std::unique_ptr< RoverCommand > create( Rover& r ) const override { return std::make_unique< AnalyseCommand >( r ); } }; struct PictureCommand : public RoverCommand { PictureCommand( Rover& r ) : RoverCommand( r, "PIC" ) { std::cout << "Picture signal transmitted!\n" << "Activating the camera...\n" << "Camera adjusted!\n"; } void call() const override; }; struct PictureCommandFactory : public AbstractCommandFactory { PictureCommandFactory() : AbstractCommandFactory( "PIC" ) {} std::unique_ptr< RoverCommand > create( Rover& r ) const override { return std::make_unique< PictureCommand >( r ); } }; struct DeleteCommand : public RoverCommand { DeleteCommand( Rover& r ) : RoverCommand( r, "DEL" ) { std::cout << "Delete signal transmitted!\n" << "Starting to search the internal cache...\n"; } void call() const override; }; struct DeleteCommandFactory : public AbstractCommandFactory { DeleteCommandFactory() : AbstractCommandFactory( "DEL" ) {} std::unique_ptr< RoverCommand > create( Rover& r ) const override { return std::make_unique< DeleteCommand >( r ); } }; struct PrintCommand : public RoverCommand { PrintCommand( Rover& r ) : RoverCommand( r, "PRT" ) { std::cout << "Print signal transmitted!\n" << "Loading the latest picture...\n"; } void call() const override; }; struct PrintCommandFactory : public AbstractCommandFactory { PrintCommandFactory() : AbstractCommandFactory( "PRT" ) {} std::unique_ptr< RoverCommand > create( Rover& r ) const override { return std::make_unique< PrintCommand >( r ); } }; struct LogCommand : public RoverCommand { LogCommand( Rover& r ) : RoverCommand( r, "LOG" ) { std::cout << "Log signal transmitted!\n" << "Loading entries...\n"; } void call() const override; }; struct LogCommandFactory : public AbstractCommandFactory { LogCommandFactory() : AbstractCommandFactory( "LOG" ) {} std::unique_ptr< RoverCommand > create( Rover& r ) const override { return std::make_unique< LogCommand >( r ); } }; struct ExitCommand : public RoverCommand { ExitCommand( Rover& r ) : RoverCommand( r, "EXT" ) { std::cout << "Exit signal transmitted!\n" << "Beginning termination...\n"; } void call() const override; }; struct ExitCommandFactory : public AbstractCommandFactory { ExitCommandFactory() : AbstractCommandFactory( "EXT" ) {} std::unique_ptr< RoverCommand > create( Rover& r ) const override { return std::make_unique< ExitCommand >( r ); } }; struct EmptyCommand : public RoverCommand { EmptyCommand( Rover& r ) : RoverCommand( r, "" ) { std::cout << "No further commands were received.\n" << "Preparing to shutting down the rover...\n"; } void call() const override; }; struct EmptyCommandFactory : public AbstractCommandFactory { EmptyCommandFactory() : AbstractCommandFactory( "" ) {} std::unique_ptr< RoverCommand > create( Rover& r ) const override { return std::make_unique< EmptyCommand >( r ); } }; class CommandFactory { private: static std::vector< std::shared_ptr< AbstractCommandFactory > > mFactories; public: CommandFactory() = default; std::unique_ptr< RoverCommand > create( Rover&, const std::string& ) const; }; std::vector< std::shared_ptr< AbstractCommandFactory > > CommandFactory::mFactories = { std::make_shared< CollectCommandFactory >(), std::make_shared< ReleaseCommandFactory >(), std::make_shared< ClearCommandFactory >(), std::make_shared< AnalyseCommandFactory >(), std::make_shared< PictureCommandFactory >(), std::make_shared< DeleteCommandFactory >(), std::make_shared< PrintCommandFactory >(), std::make_shared< LogCommandFactory >(), std::make_shared< ExitCommandFactory >(), std::make_shared< EmptyCommandFactory >() }; std::unique_ptr< RoverCommand > CommandFactory::create( Rover& r, const std::string& command ) const { for ( auto it = mFactories.begin(); it != mFactories.end(); ++it ) { if ( command == (*it)->mCommand ) { return (*it)->create( r ); } } return nullptr; } //////////////////////////////////////// // // // Command Processing Module // // ------------------------- // // The core of the rover. The module // // receives and processes the input, // // which is transformed into commands // // and 'sent' to the rover, which is // // then able to execute the commands. // // // //////////////////////////////////////// class CommandProcessingModule { private: Rover& mLinkedRover; std::string mInput; std::deque< std::unique_ptr< RoverCommand > > mLog; void logCommand( std::unique_ptr< RoverCommand >& ); void handleMoveCommand(); void handleTurnCommand(); public: CommandProcessingModule( Rover& ); void printLog() const; void getInput(); void processInput(); }; CommandProcessingModule::CommandProcessingModule( Rover& rover) : mLinkedRover{ rover }, mInput{}, mLog{} {} void CommandProcessingModule::logCommand( std::unique_ptr< RoverCommand >& ptr ) { if ( mLog.size() == logCapacity ) { mLog.pop_front(); } mLog.push_back( std::move( ptr ) ); } void CommandProcessingModule::printLog() const { std::cout << "Command Log:\n"; for ( std::unique_ptr< RoverCommand > const& ptr : mLog ) { std::cout << "~ <" << ptr->mCommand << ">\n"; } } void CommandProcessingModule::getInput() { std::cout << std::endl; drawBorder( '#' ); std::cout << "\n>> "; std::getline( std::cin, mInput ); std::cout << mInput << "\n"; } void CommandProcessingModule::processInput() { std::string baseCommand = mInput.substr( 0, 3 ); std::unique_ptr< RoverCommand > newCommand; if ( baseCommand == "MOV" ) { handleMoveCommand(); return; } else if ( baseCommand == "TRN" ) { handleTurnCommand(); return; } else { CommandFactory factory; newCommand = factory.create( mLinkedRover, baseCommand ); } if ( newCommand ) { newCommand->call(); logCommand( newCommand ); } else { std::cout << "Unknown command <" << mInput << ">. Processing of the command has been stopped.\n"; } } //////////////////////////////////////// // // // Rover // // ----- // // This is the actual rover class. // // Just as anything else on the // // surface, it is an object and thus // // inherits from class Object. // // // //////////////////////////////////////// class Rover : public Object { private: CommandProcessingModule mCommandModule; RockContainer mContainer; std::deque< Picture > mPictures; Surface& mSurface; uint16_t mDegrees; bool isOnline; bool nextCellIsEmpty( const int16_t, const int16_t ) const noexcept; Coordinates moveForward( const int16_t ) noexcept; Coordinates moveBackward( const int16_t ) noexcept; void moveRover( const int16_t, const Coordinates& ) noexcept; void turnLeft() noexcept; void turnRight() noexcept; void collectRock(); void releaseRock() noexcept; void clearRocks() noexcept; void analyseRock() const; void takePicture() noexcept; void deletePicture() noexcept; void showPicture() const noexcept; void printLog() const noexcept; void shutdownRover() noexcept; public: Rover( const int16_t, const int16_t, Surface&) noexcept; void requestInput(); void processInput(); inline const Surface& getSurface() const { return mSurface; } inline bool getStatus() const { return isOnline; } friend class MoveCommand; friend class TurnCommand; friend class CollectCommand; friend class ReleaseCommand; friend class ClearCommand; friend class AnalyseCommand; friend class PictureCommand; friend class DeleteCommand; friend class PrintCommand; friend class LogCommand; friend class ExitCommand; friend class EmptyCommand; }; Rover::Rover( const int16_t x, const int16_t y, Surface& surface ) noexcept : Object( x, y, OBJECT_TYPES::ROVER ), mCommandModule{ CommandProcessingModule( (*this) ) }, mContainer{ RockContainer() }, mSurface{ surface }, mDegrees{ 0 }, isOnline{ true } { std::cout << "Rover has gone online!\n" << "Connecting the Command Processing Module...\n" << "Connection stable!\n" << "Waiting for signals...\n\n"; } bool Rover::nextCellIsEmpty( const int16_t x, const int16_t y ) const noexcept { if ( x < 0 || x >= rowCells ) { return false; } if ( y < 0 || y >= columnCells ) { return false; } for ( auto it = mSurface.begin() + 1; it != mSurface.end(); ++it ) { if ( (*it)->getX() == x && (*it)->getY() == y && (*it)->getObjectType() == OBJECT_TYPES::OBSTACLE ) { std::cout << "Obstacle detected in front of the rover!\n" << "Stopping movement...\n" << "Movement stopped!\n"; return false; } } return true; } Coordinates Rover::moveForward( const int16_t distance ) noexcept { int16_t dX {}; int16_t dY {}; if ( mDegrees % 90 == 0 ) { dX = ( mDegrees == 0 || mDegrees == 180 ? 0 : mDegrees < 180 ? 1 : -1 ); dY = ( mDegrees == 90 || mDegrees == 270 ? 0 : mDegrees < 180 ? -1 : 1 ); } else { dX = ( mDegrees < 180 ? 1 : -1 ); dY = ( mDegrees == 135 || mDegrees == 225 ? 1 : -1 ); } return { dX, dY }; } Coordinates Rover::moveBackward( const int16_t distance ) noexcept { int16_t dX {}; int16_t dY {}; if ( mDegrees % 90 == 0 ) { dX = ( mDegrees == 0 || mDegrees == 180 ? 0 : mDegrees < 180 ? -1 : 1 ); dY = ( mDegrees == 90 || mDegrees == 270 ? 0 : mDegrees < 180 ? 1 : -1 ); } else { dX = ( mDegrees > 180 ? 1 : -1 ); dY = ( mDegrees == 45 || mDegrees == 315 ? 1 : -1 ); } return { dX, dY }; } void Rover::moveRover( const int16_t distance, const Coordinates& coordinates ) noexcept { for ( int16_t index { distance } ; index > 0 && nextCellIsEmpty ( mCoordinates.x + coordinates.x, mCoordinates.y + coordinates.y ); --index ) { mCoordinates.x += coordinates.x; mCoordinates.y += coordinates.y; } } void Rover::turnLeft() noexcept { if ( mDegrees == 0 ) { mDegrees = 315; } else { mDegrees -= 45; } std::cout << "New orientation: " << mDegrees << "deg\n"; } void Rover::turnRight() noexcept { if ( mDegrees == 315 ) { mDegrees = 0; } else { mDegrees += 45; } std::cout << "New orientation: " << mDegrees << "deg\n"; } void Rover::collectRock() { for ( auto it = mSurface.begin() + 1; it != mSurface.end(); ++it ) { if ( (*it)->getObjectType() == OBJECT_TYPES::ROCK && (*it)->getX() == mCoordinates.x && (*it)->getY() == mCoordinates.y ) { if ( mContainer.size() < mContainer.capacity() ) { mContainer.push ( *( static_cast< Rock* >( it->get() ) ) ); mSurface.erase ( it ); std::cout << "A suitable rock was found and has been picked up.\n" << "Number of rocks in the container: " << mContainer.size() << "\n"; return; } else { std::cout << "The container has reached its maximum capacity.\n"; return; } } } std::cout << "Unable to detect a rock.\n"; } void Rover::releaseRock() noexcept { if ( mContainer.size() > 0 ) { mContainer.pop(); std::cout << "The topmost rock in the container has been released.\n" << "Number of rocks in the container: " << mContainer.size() << "\n"; } else { std::cout << "The container is already empty.\n"; } } void Rover::clearRocks() noexcept { if ( mContainer.size() > 0 ) { mContainer.clear(); std::cout << "The container has been emptied.\n"; } else { std::cout << "The container is already empty.\n"; } } void Rover::analyseRock() const { if ( mContainer.size() > 0 ) { std::cout << mContainer.back(); } else { std::cout << "Analysis failed. No rocks in the container...\n"; } } void Rover::takePicture() noexcept { if ( mPictures.size() < imageCapacity ) { mPictures.push_back( Picture( mSurface ) ); std::cout << "The rover took a picture of its surrounding area.\n" << "Number of pictures saved: " << mPictures.size() << "\n"; } else { std::cout << "Not enough memory space to save another picture.\n" << "Release an image to gain more storage capacity.\n"; } } void Rover::deletePicture() noexcept { if ( mPictures.size() > 0 ) { mPictures.pop_front(); std::cout << "The oldest picture has been deleted from the storage.\n" << "Remaining pictures: " << mPictures.size() << "\n"; } else { std::cout << "The internal memory space is already empty.\n"; } } void Rover::showPicture() const noexcept { if ( mPictures.size() > 0 ) { mPictures.back().print(); } else { std::cout << "Operation failed. No images stored in the internal memory...\n"; } } void Rover::printLog() const noexcept { mCommandModule.printLog(); } void Rover::shutdownRover() noexcept { isOnline = false; std::cout << "\nShutting down the rover...\n" << "Connection cut!\n\n" << "Rover has gone offline!"; } void Rover::requestInput() { mCommandModule.getInput(); } void Rover::processInput() { mCommandModule.processInput(); } //////////////////////////////////////// // // // Module Implementations // // ----------------------- // // Implementation of the missing // // methods from the command // // processing module. // // // //////////////////////////////////////// void CommandProcessingModule::handleMoveCommand() { if ( mInput.find_last_of( 'F' ) != std::string::npos ) { std::unique_ptr< RoverCommand > newCommand( new MoveCommand( mLinkedRover, MoveCommand::FORWARD, ( mInput.back() + 2 ) % 10 ) ); newCommand->call(); Mars::render( newCommand->mRover.getSurface() ); logCommand( newCommand ); } else if ( mInput.find_last_of( 'B' ) != std::string::npos ) { std::unique_ptr< RoverCommand > newCommand( new MoveCommand( mLinkedRover, MoveCommand::BACKWARD, ( mInput.back() + 2 ) % 10 ) ); newCommand->call(); Mars::render( newCommand->mRover.getSurface() ); logCommand( newCommand ); } else { std::cout << "Incorrect direction in the <" << mInput << "> command.\n"; } } void CommandProcessingModule::handleTurnCommand() { std::unique_ptr< RoverCommand > newCommand; if ( mInput.find_last_of( 'L' ) != std::string::npos ) { newCommand = std::unique_ptr< RoverCommand >( new TurnCommand( mLinkedRover, TurnCommand::LEFT ) ); } else if ( mInput.find_last_of( 'R' ) != std::string::npos ) { newCommand = std::unique_ptr< RoverCommand >( new TurnCommand( mLinkedRover, TurnCommand::RIGHT ) ); } else { std::cout << "Incorrect direction in the <" << mInput << "> command.\n"; } if ( newCommand ) { newCommand->call(); logCommand( newCommand ); } } //////////////////////////////////////// // // // Command Implementations // // ----------------------- // // Implementation of the missing // // call() methods from the different // // commands. // // // //////////////////////////////////////// void MoveCommand::call() const { switch ( Direction ) { case FORWARD: { mRover.moveRover( distance, mRover.moveForward( distance ) ); } break; case BACKWARD: { mRover.moveRover( distance, mRover.moveBackward( distance ) ); } break; } } void TurnCommand::call() const { switch ( Direction ) { case LEFT: { mRover.turnLeft(); } break; case RIGHT: { mRover.turnRight(); } break; } } void CollectCommand::call() const { mRover.collectRock(); } void ReleaseCommand::call() const { mRover.releaseRock(); } void ClearCommand::call() const { mRover.clearRocks(); } void AnalyseCommand::call() const { mRover.analyseRock(); } void PictureCommand::call() const { mRover.takePicture(); } void DeleteCommand::call() const { mRover.deletePicture(); } void PrintCommand::call() const { mRover.showPicture(); } void LogCommand::call() const { mRover.printLog(); } void ExitCommand::call() const { mRover.shutdownRover(); } void EmptyCommand::call() const { mRover.shutdownRover(); } //////////////////////////////////////// // // // Main Function // // ------------- // // The main function of the program. // // // //////////////////////////////////////// int main() { Surface marsSurface {}; marsSurface.push_back ( std::make_unique< Rover >( rowCells / 2, columnCells / 2, marsSurface ) ); Mars::initialize( marsSurface ); Mars::render( marsSurface ); Rover* myRover = static_cast< Rover* >( marsSurface.front().get() ); while ( myRover->getStatus() ) { myRover->requestInput(); myRover->processInput(); } return 0; }

[Contest] Mars Rover