DEV Community

💻 Arpad Kish 💻
💻 Arpad Kish 💻

Posted on

Exploring a Command-Line Hangman Implementation in Node.js

#node #gamedev

Classic games are a fantastic way to explore programming concepts, and few are as universally recognized as Hangman. In this article, we'll dive into a clean, event-driven implementation of a Hangman game written in JavaScript for the Node.js runtime environment.

By examining the structure of this specific GitHub repository, we can uncover some excellent practices for building interactive Command Line Interface (CLI) applications using object-oriented programming and event emitters.

The Project Structure

The repository is lightweight and purposefully structured, consisting of three main files:

  • index.js: The core application logic and game engine.
  • words.txt: A massive, comprehensive dictionary text file containing tens of thousands of words.
  • README.md: The standard markdown file for repository documentation.

The Tech Stack: Core Node.js Modules

The beauty of this implementation is that it relies entirely on native Node.js modules, requiring no external dependencies like NPM packages. The script imports three key modules right at the top:

  1. readline: Essential for creating the interactive CLI prompt that asks the user for their letter guesses.
  2. fs (File System): Used to read the words.txt file into memory so the game can randomly select a word for the player to guess.
  3. events: Specifically the EventEmitter class, which allows the game to broadcast state changes (like winning or losing).

Inside the Hangman Class

At the heart of the game is the Hangman class, which extends Node's EventEmitter. This is a brilliant design choice because it allows the game logic to decouple the interactive prompts from the ultimate game state (Game Over).

1. State Initialization

When a new game instance is created, the constructor initializes the game state:

constructor(readlineProvider, wordToGuess = "testing", guessesLeft = 5) {
    super();
    this.rl = readlineProvider;
    this.wordCount = wordToGuess.split(' ').length;
    this.guessesLeft = guessesLeft;
    // ...
Enter fullscreen mode Exit fullscreen mode

It accepts a readline interface, the target word, and sets a default limit of 5 incorrect guesses. It dynamically masks the word, transforming letters into underscores _ while preserving spaces if the target is a multi-word phrase.

2. The Gameplay Loop

The game kicks off with the start() method, which provides the player with their initial instructions, calculating whether they are guessing a single word or multiple words, and reminding them of their remaining guesses.

From there, the application enters an asynchronous loop:

  • Prompting the user: A method named _continue() utilizes the readline provider to pause execution and wait for the user to type a letter.
  • Processing input: The _processLetter() method acts as a validation layer, ensuring the user only inputs a single character at a time.
  • Updating State: The core logic checks if the guessed letter exists in the wordToGuess. If it does, the underscores in the masked word are replaced with the correct letter. If it doesn't, the guessesLeft counter is decremented.

3. Event-Driven Game Over

Because the class extends EventEmitter, it defines a constant dictionary of events:

const HANGMAN_EVENTS = {
    GAME_OVER: 'GAME_OVER'
};
Enter fullscreen mode Exit fullscreen mode

Whenever the player successfully unmasks the entire word, or their guessesLeft drops to zero, the class emits the GAME_OVER event. The main execution script listens for this event to gracefully close the readline interface and terminate the Node process.

The Dictionary: words.txt

A Hangman game is only as good as its vocabulary. This repository includes a sprawling words.txt file packed with over 47,000 entries—ranging from simple words like "apple" to highly complex biological and geographical terms. Because the application dynamically reads from this file, the replayability is practically infinite.

Conclusion

This Hangman repository is an excellent showcase of intermediate JavaScript concepts. It demonstrates how to effectively manage application state within a class, handle asynchronous user input via the command line, and use an event-driven architecture to manage the lifecycle of an application. Whether you are a beginner looking to understand the readline module or an intermediate developer studying OOP in JavaScript, this code serves as a clean, highly readable educational resource.

https://github.com/arpad1337/hangman

Top comments (0)