Hey, I’m Kashyap (Kash) Tubati. I work toward becoming a thoughtful software engineer by shipping games, utilities, and small experiments in code.

Development Environment

Every project begins with the tooling — these are the platforms I rely on day to day.


My Lessons

A few of the teaching artifacts I’ve put together along the way — click in to read them.


Class Progress

Coding milestones from class, each one playable in the browser.


My Projects

My main build — the Gate Game — plus the full source on GitHub.


About the Gate Game 🚪

The Gate Game is a multi-stage JavaScript game built on top of an object-oriented engine. The project is split into three connected sublevels — Cannon Ball, Escape Room, and Zone Catch — each one exercising a different set of CS 111 concepts under a shared engine.

Object-Oriented Programming: Every sublevel is wrapped in its own class (GameLevelCannonball, GameLevelEscaperoom, GameLevelZonecatch) that accepts a gameEnv in its constructor and assembles the level out of engine primitives. Entities like Player, Npc, Enemy, and Collectible all inherit from a shared GameObject → Character base chain, so each level just composes the pieces it needs.

// Composition through the engine's class hierarchy
{ class: Player,      data: sprite_data_player    },
{ class: Npc,         data: sprite_data_gatekeeper },
{ class: Enemy,       data: sprite_data_cannon    },
{ class: Collectible, data: sprite_data_key       },

Methods & Parameters: Engine classes expose overridable methods like update(), draw(), and handleCollision(other, direction). Each sublevel customizes behavior through helper functions — for example, a zone-builder that converts a relative rectangle into pixel-space configuration.

// Helper that takes parameters and returns a config object
function zone(id, [rx, ry, rw, rh]) {
  return {
    id,
    x: Math.round(rx * width),
    y: Math.round(ry * height),
    w: Math.round(rw * width),
    h: Math.round(rh * height),
  };
}

Control Structures & Data Types: Arrays hold level data (cannon trajectories, room puzzles, capture zones), booleans gate state (isLocked, hasKey, zoneCleared), and strings handle sprite paths and dialogue lines fed into the DialogueSystem.

// Arrays of object literals drive the level layout
const cannons = [
  { id: 'c1', x: 0.10, y: 0.80, angle: 45, power: 12 },
  { id: 'c2', x: 0.50, y: 0.70, angle: 30, power: 15 },
  { id: 'c3', x: 0.85, y: 0.85, angle: 60, power: 10 },
];

Input/Output & Async: Player movement runs through the engine's keyboard listeners; the gatekeeper NPC triggers async transitions when a sublevel is cleared, using requestAnimationFrame for the fade and setTimeout to hand control to GameControl.transitionToLevel().

// Async hand-off to the next gate
requestAnimationFrame(() => {
  fade.style.opacity = '1';
  setTimeout(() => {
    topGame.transitionToLevel();
  }, 800);
});


CS 111 Learning Objectives, Evidence & Assessment

Click any objective below to expand its evidence and assessment details. Eight categories, 35 objectives, each linked to its own walkthrough page.

🏛️ Object-Oriented Programming 06 objectives

Designing modular, reusable game pieces through classes, inheritance, and overrides — the load-bearing structure under every entity in the Gate Game.

01 Writing Classes
At least 2 custom character classes that extend an engine base class.
Code review of Player.js, Npc.js, Enemy.js
02 Methods & Parameters
Methods that take real parameters, e.g. collisionHandler(other, direction).
Code review of method signatures with 2+ parameters
03 Instantiation & Objects
Game entities instantiated through the GameLevel configuration block.
Code review of GameLevel setup arrays
04 Inheritance (Basic)
A class hierarchy at least two levels deep (e.g. GameObject → Character → Player).
Code review of extends chain
05 Method Overriding
Subclass overrides of update(), draw(), or handleCollision().
Code review of polymorphic implementations
06 Constructor Chaining
Use of super() to forward initialization data up the chain.
Code review of super(data, gameEnv) calls
🔁 Control Structures 03 objectives

The loops and branches that drive the game loop — stepping frames, resolving collisions, and reacting to player state.

01 Iteration
Loops over game-object arrays and animation frames.
Code review of for, forEach, while usage
02 Conditionals
Collision detection and state transitions guarded by if/else.
Code review of conditional branches
03 Nested Conditions
Multi-factor logic (e.g. power-up + collision + facing direction).
Code review of nested conditionals
🧮 Data Types 05 objectives

The values that position, label, flag, and configure everything inside the level.

01 Numbers
Position, velocity, and score tracking.
Code review of numeric properties
02 Strings
Character names, sprite paths, level state labels.
Code review of string handling
03 Booleans
State flags like isJumping, isPaused, hasKey.
Code review of boolean logic
04 Arrays
Collections of game objects and level data.
Code review of array operations
05 Objects (JSON)
Sprite-data and configuration object literals.
Code review of object literal usage
➕ Operators 03 objectives

Math operators move the world, boolean operators decide what happens, string operators assemble the text the player reads.

01 Mathematical
Physics math (gravity, velocity, collision response).
Code review of arithmetic in physics paths
02 String Operations
Path building and on-screen text composition.
Code review of template literals and concatenation
03 Boolean Expressions
Compound conditions in level logic.
Code review of &&, ||, !
🎮 Input / Output 06 objectives

The connection between the player and the game world, and between the game and external services like the leaderboard and NPC AI.

01 Keyboard Input
Arrow, Space, and WASD controls bound through event listeners.
Testing of key event handlers
02 Canvas Rendering
Sprite, background, and platform drawing through the Canvas API.
Code review of draw() implementations
03 GameEnv Configuration
Canvas sizing, difficulty levels, and global game settings.
Code review of GameEnv.create() and GameSetup.js
04 API Integration
Leaderboard API integration (POST/GET scores).
Code review of fetch calls with error handling
05 Asynchronous I/O
Promises or async/await around API requests.
Code review of async/await or .then() chains
06 JSON Parsing
Parsing leaderboard and NPC-AI responses.
Code review of JSON.parse() and destructuring
📝 Documentation 03 objectives

JSDoc, mini-lessons, and annotated highlights that turn working code into code that explains itself.

01 Code Comments
JSDoc on custom classes and methods.
Code review with comment density above 10%
02 Mini-Lesson Documentation
Comic / visual post with an embedded runtime demo of the level.
Portfolio review of the mini-lesson page
03 Code Highlights
Annotated snippets covering OOP, APIs, and collision logic.
Portfolio review of highlighted examples
🐛 Debugging 06 objectives

Working across the Chrome DevTools surface — from console traces in the game loop to network failures in the leaderboard API.

01 Console Debugging
console.log tracing for state, variables, and method calls.
Code review of strategic logging in update/collision paths
02 Hit Box Visualization
Drawn collision boundaries used to tune detection.
Live demo toggling hit-box overlays
03 Source-Level Debugging
Breakpoints in the Sources tab to step through execution.
Demo of pausing and inspecting flow
04 Network Debugging
Network-tab inspection of API calls, CORS, and status codes.
Demo of inspecting fetch requests and responses
05 Application Debugging
Cookies, localStorage, and session data for login/state.
Demo of the Application tab in use
06 Element Inspection
Inspecting the canvas and surrounding DOM in the Elements panel.
Demo of element-property inspection
✅ Testing & Verification 03 objectives

Showing the level actually plays and the integrations actually work — through gameplay, end-to-end checks, and graceful error handling.

01 Gameplay Testing
Level completion, character interaction, and collision verified by play.
Live demo of a clean playthrough
02 Integration Testing
Leaderboard and NPC-AI APIs exercised against the live backend.
Demo of score saves and AI responses
03 API Error Handling
try/catch around API calls and network failures.
Code review of fetch-failure handling

CS 111 Required Evidence Checklist

The high-level rubric the 35 objectives above roll up into. Each item has to be visibly present in the project for credit.

  • ✅ 2+ custom character classes extending base classes (Character, Enemy, or Npc)
  • ✅ 5+ methods with parameters and return values (overriding update(), draw(), handleCollision(), etc.)
  • ✅ GameLevel configuration that uses object literals to instantiate entities
  • ✅ JSDoc comments on custom classes and methods (>10% comment density)
  • ✅ API integration: leaderboard (POST/GET scores) plus NPC AI, both with error handling
  • ✅ Debugging competence across DevTools (Console, Network, Application, Sources) for game logic, APIs, and login/state
  • ✅ Mini-lesson documentation hosted in the personal portfolio (comic/visual style with an embedded runtime demo)
  • ✅ Code highlights covering OOP hierarchy, API calls, collision logic, and state management
  • ✅ A complete, playable custom level tested in GameBuilder and in the team repository

JavaScript is accepted in place of Java for CS 111 credit at Mira Costa College. See the CS 111 Course Info and the Math & CS Pathway.