Systems that provide automated game-design support — whether fully automated game generators, or tools to assist human designers — must be able to maintain a representation of a game design and add or remove game mechanics to support incrementally modifying the game. The system should then be able to reason about the design to support the designer. For example, it might point out that the set of mechanics makes the game unwinnable; or that there's only one complex possible way to beat the game; or that some room is impossible to get to. In addition, the same representation should be actually playable as a game. Existing game representations encode a fairly narrow range of games, most commonly symmetric board games; these representations are also difficult to extend or revise. We propose an architecture based on the event calculus, a logical representation designed for reasoning about time in an elaboration-tolerant way, meaning that designs can be changed by adding or removing sets of axioms rather than modifying brittle hard-coded representations. The resulting game design is a declarative specification in formal logic, so can be critiqued by making queries that are answered through logical inference. Since it specifies the game's simulation rules, it may be executed by logical inference as well; if symbols specifying input and graphical representation are appropriately mapped to input devices and a graphical display, the same declarative representation can be executed as a fully interactive, graphical game. We describe how to organize a library of game-design mechanics using this event-calculus framework, and describe a simple tile-based game, showing how it can be easily modified, critiqued and debugged, and played.