Hi! My name is Chetan Tiduwar, and I strive towards becoming a skilled computer scientist, building games, tools, and experiences through code.

Development Environment

Coding starts with tools, explore these tools and procedures with a click.

OCS GitHub VSCode.dev

My Lessons

Foundations in Tech are essential, click to see some of my lesson creations.

JS Basics

JS Variables

Gamerunner

Networking

Class Progress

Here is my game progress through coding, click to see these in the browser.

🐍 Snake 🐟 Fish 🎮 Gamify 🚀 CS Pathway 🗼 GateGame

My Projects

Here are some tools and apps I built, click to try them!

Exam Predictor Grade Predictor Study Tracker Score Predictor

About GateGame 🗼

GateGame is a multi-level platformer game built with JavaScript using an object-oriented game engine. I contributed by building the Maze of Shadows sublevel, which demonstrates core CS 111 concepts throughout.

Object-Oriented Programming: The level is structured as a class GameLevelMazeSub with a constructor that takes a gameEnv parameter and instantiates all game objects. Characters like Player, Npc, and SplineBarrier are imported and extended from base classes, forming a multi-level inheritance chain (e.g., GameObject → Character → Player).

// Inheritance and instantiation — Player extends a base Character class
{ class: Player, data: sprite_data_octopus },
{ class: Npc,    data: sprite_data_shadow  },
{ class: SplineBarrier, data: seg1 },

Methods & Parameters: NPCs use methods like interact() and reaction() with custom dialogue logic. The spline() helper function takes an id and points array, maps relative coordinates to pixel values, and returns a barrier config object.

// Method with parameters — converts relative coords to pixel values
function spline(id, points) {
  return {
    id,
    splinePoints: points.map(([px, py]) => ({
      x: Math.round(px * width),
      y: Math.round(py * height)
    })),
    lineWidth: 22,
  };
}

Control Structures & Data Types: The level uses arrays to store spline path segments and NPC configurations, booleans to control dialogue state (isDialogueOpen()), and strings for sprite paths and character greetings.

// Array of objects used to define the winding maze path
const seg1 = spline('seg1', [
  [0.03, 0.945],
  [0.09, 0.940],
  [0.20, 0.920],
  [0.28, 0.895],
]);

Input/Output & Async: The player is controlled via WASD keyboard input configured through event listeners. The Exit Warden NPC triggers a fade transition using requestAnimationFrame and setTimeout for async sequencing, then loads the next level via topGame.transitionToLevel().

// Async transition to next level on player choice
requestAnimationFrame(() => {
  fade.style.opacity = '1';
  setTimeout(() => {
    topGame.transitionToLevel();
  }, 800);
});

CS 111 Learning Objectives, Evidence & Assessment

Eight categories of learning objectives, each item showing the project evidence required and the assessment method used to verify it. Click any card to open a dedicated page with code examples and walkthroughs.

🏛️ Object-Oriented Programming

Building reusable, modular game components through classes, inheritance, and method overriding — the architectural backbone of every entity in the game.

Writing Classes

Create minimum 2 custom character classes extending base classes.

Code review: Player.js, NPC.js, Enemy.js

Methods & Parameters

Implement methods with parameters (e.g. collisionHandler(other, direction)).

Code review: Method signatures with 2+ parameters

Instantiation & Objects

Instantiate game objects in GameLevel configuration.

Code review: GameLevel setup objects

Inheritance (Basic)

Create class hierarchy with 2+ levels (e.g. GameObject → Character → Player).

Code review: extends keyword, inheritance chain

Method Overriding

Override parent methods (update(), draw(), handleCollision()).

Code review: Polymorphic implementations

Constructor Chaining

Use super() to chain constructors and forward initialization data.

Code review: super(data, gameEnv) calls

🔁 Control Structures

Loops and conditionals that drive the game loop — animating frames, detecting collisions, and reacting to player state.

Iteration

Use loops for game object arrays and animation frames.

Code review: for, forEach, while loops

Conditionals

Implement collision detection and state transitions.

Code review: if/else, nested conditions

Nested Conditions

Complex game logic (e.g. power-up + collision + direction).

Code review: Multi-level conditionals

🧮 Data Types

The values that move, name, flag, and configure everything in the game world.

Numbers

Position, velocity, score tracking.

Code review: Numeric properties

Strings

Character names, sprite paths, game states.

Code review: String manipulation

Booleans

Flags such as isJumping, isPaused, isVulnerable.

Code review: Boolean logic

Arrays

Game object collections and level data.

Code review: Array operations

Objects (JSON)

Configuration objects and sprite data.

Code review: Object literals

➕ Operators

Math operators move the world, boolean operators gate every choice, string operators build the text the player sees.

Mathematical

Physics calculations (gravity, velocity, collision).

Code review: +, -, *, / in physics

String Operations

Path concatenation and on-screen text display.

Code review: Template literals, concatenation

Boolean Expressions

Compound conditions in game logic.

Code review: &&, ||, !

🎮 Input / Output

The bridge between the player and the game world — and between the game and external services like the leaderboard and NPC AI.

Keyboard Input

Arrow keys, Space, WASD controls using event listeners.

Testing: Key event handlers respond correctly

Canvas Rendering

Draw sprites, backgrounds, platforms using the Canvas API.

Code review: draw() method implementations

GameEnv Configuration

Set canvas size, difficulty levels, game settings.

Code review: GameEnv.create() and GameSetup.js

API Integration

Implement Leaderboard API (POST/GET scores).

Code review: Fetch calls with error handling

Asynchronous I/O

Use async/await or Promises for API calls.

Code review: async/await or .then() chains

JSON Parsing

Parse API responses (leaderboard data, AI responses).

Code review: JSON.parse(), object destructuring

📝 Documentation

JSDoc comments, mini-lessons, and code highlights that turn code that works into code that teaches.

Code Comments

JSDoc comments for classes and methods.

Code review: Comment density >10%

Mini-Lesson Documentation

Comic / visual post with embedded runtime game demo.

Portfolio review: Mini-lesson in personal portfolio

Code Highlights

Annotate key code snippets (OOP, APIs, collision).

Portfolio review: Highlighted code examples with explanations

🐛 Debugging

Using Chrome DevTools across the full stack — from console logs in the game loop to network errors in the leaderboard API.

Console Debugging

Use console.log to track game state, variables, method calls.

Code review: Strategic logging in update/collision methods

Hit Box Visualization

Draw / visualize collision boundaries to refine detection.

Demo: Toggle hit box display, adjust collision rectangles

Source-Level Debugging

Set breakpoints in DevTools, step through code execution.

Demo: Use Sources tab to pause and inspect code flow

Network Debugging

Examine Network tab for API calls, CORS errors, response status.

Demo: Inspect fetch requests, response data, error messages

Application Debugging

Examine cookies, localStorage, session data for login/state.

Demo: Application tab inspection of stored data

Element Inspection

Use Element viewer to inspect canvas, DOM elements, styles.

Demo: Inspect element properties and game object state

✅ Testing & Verification

Proving the level is playable and the integrations actually work — through gameplay, end-to-end API tests, and resilient error handling.

Gameplay Testing

Test level completion, character interactions, collision detection.

Live demo: Play through level without critical bugs

Integration Testing

Test API integration (Leaderboard, NPC AI) with live backend.

Demo: Successful score saving and AI responses

API Error Handling

Try/catch blocks for API calls, network error handling.

Code review: Error handling for fetch failures

CS 111 Required Evidence Checklist

The high-level rubric all 35 learning objectives above roll up into. Each item below must be demonstrably present in the project for college credit.

• ✅ 2+ custom character classes extending base classes (Character, Enemy, or NPC)
• ✅ 5+ methods with parameters and return values (override update(), draw(), handleCollision(), etc.)
• ✅ GameLevel configuration using Object Literals to instantiate game objects
• ✅ JSDoc comments on custom classes and methods (>10% comment density)
• ✅ API Integration: Leaderboard (POST/GET scores) + NPC AI interaction with error handling
• ✅ Debugging competency: Use DevTools (Console, Network, Application, Sources) to debug game logic, APIs, and login/state
• ✅ Mini-lesson documentation in personal portfolio (comic/visual style with embedded runtime demo)
• ✅ Code highlights showing OOP hierarchy, API calls, collision logic, and state management
• ✅ Complete, playable custom level tested in GameBuilder and team repository

---

JavaScript is approved as a substitute for Java for CS 111 credit at Mira Costa College. See the CS 111 Course Info and the Math & CS Pathway.