I am looking for a software engineering project idea (based on Object Oriented Programming) which does not include financial/accounting module, yet provides reasonable challenges in terms of research and modelling to undergraduate students. As this system needs to be implemented, it is preferable that web-based projects are not considered, as they require extensive coding challenges. The challenge is best to be in terms of OO design and requirements gathering.
Let me first make a suggestion. First, understand, yourself, what OO really means at a deep level. It is not, fundamentally, about inheritance, and when inheritance is employed it should be done so that all subclasses of a given class have exactly the same interface with no additional public methods. To break this rule introduces entropy into the program, meaning that a programmer needs to understand the specifics of each class to employ it correctly.
I've found text based games a poor way to do this, since the "things" that you define usually need different methods for their actions. Inheritance gives you very little in such a situation.
Instead OO is best employed to implement composition, in which a complex object is composed from different parts and the parts themselves may be simpler (or a further decomposition needed). But, in a situation like this, the parts can be defined by interfaces and the class hierarchies are very short (usually just 1).
So, the fundamental idea is "Has a", not "Is a". A complex object "has" parts.
A calculator is a good choice of project, since it has Keys, one or more Displays and some internal Operations that make it work. A Calculator is composed of these parts and each part is defined by a class. Lots of classes, few hierarchies, lots of object interactions.
Another one, if your students can handle it is actually a simulator for a simple computer. In particular, each operation of the simulator can be defined by a class, and all of the classes have exactly the same interface. The "Fetch, Increment, Decode, Do" cycle of a simple machine is easy to write and the operations implement methods for Decode and Do.
But any complex item that can be decomposed into parts can serve as the basis of a project. The overall item's class has fields that are objects (not primitives) and the objects are defined by classes tailored to the operation of that part of the whole.
This gives a lot of practice in writing classes to implement "things", and doesn't fall in to the trap of wanting a "subclass" that is "something like" its superclass but not exactly and needs an extended interface that needs to be defined (and remembered) for each case.
I find that the Strategy and Decorator design patterns are really helpful in implementing the ideas above. In particular, one can build a complex program that has cyclomatic complexity = 1. The implication is that all of the complexity is in the interactions between objects
If this is for high school use, then simulating a simple computer is an excellent choice (IMO), since it dispels some of the mystery of computation. Once the simple computer is built, one can also write a compiler for a simple higher level language that compiles to instructions for the simple computer. This can be as simple or as complex as you like, but a recursive descent compiler is simple and emphasizes the importance of recursion, which is another goal of courses for novices.
If you're looking for AP Computer Science A-level object stuff, Greenfoot is excellent. It's an OO game-design environment created specifically for teaching about OO. It's free (though there is a textbook that can be quite helpful), and there is a large teacher community that regularly posts new labs and assignments.