Character skeleton1

docs/egdd.md

@@ -1 +1,181 @@
-REPLACE THIS TEXT WITH YOUR EGDD MARKDOWN.
+# Alliance vs The Council 
+
+
+## Elevator Pitch
+
+A tower defense game where the user must survive an onslaught of creatures by placing towers using Unix commands
+
+
+## Influences (Brief)
+
+- *Plants Vs Zombies*:
+  - Medium: *Video Game*
+  - Explanation: *This game is a major influence on what we are creating. As we are taking this idea and expanding it. We are utilizing the idea of a board-based tower defense game and modifying it by forcing the player to use Unix commands to move around.*
+- *CISC210*:
+  - Medium: *UD Course*
+  - Explanation: *CISC201 is a UD course where we learned basic terminal commands to be able to gain a better understanding of UNIX. By modeling our game based on some of the material we learned we can gain a better understanding of how to make the game educational.*
+- *DnD / Baulders Gate*:
+  - Medium: *Game*
+  - Explanation: *We are using the fantasy aspect of DnD to change around the allies and enemies. This influence has a large variety of small and large-scale enemies for us to use to make the game more interesting to look at. This also works for the placeable allies as we can use the various classes as stackable/movable/combinable characters.*
+
+## Core Gameplay Mechanics (Brief)
+
+*Give a very high-level description of any core gameplay mechanics*
+
+- *Health*
+- *Battle Phases (Buying phase and monster wave phase)*
+- *Level progression*
+- *Currency*
+
+# Learning Aspects
+
+
+## Learning Domains
+
+*Unix Commands*
+
+## Target Audiences
+
+Middle School to high school-aged kids new to Unix commands
+
+## Target Contexts
+
+*This would be used within a lesson plan of a *
+
+## Learning Objectives
+
+*Remember, Learning Objectives are NOT simply topics. They are statements of observable behavior that a learner can do after the learning experience. You cannot observe someone "understanding" or "knowing" something.*
+
+- *Unix Commands*: *By the end of instruction, students will be able to identify common Unix commands and describe their effects.*
+- *Unix Complexity*: *Students should be able to combine unix commands to do more complex tasks.*
+
+## Prerequisite Knowledge
+
+*What do they need to know prior to trying this game?*
+
+- *An idea of what Unix commands are*
+- *Why they would use Unix commands*
+
+## Assessment Measures
+
+*Given a preexisting directory and be able to traverse and modify it with little to no help*
+
+
+# What sets this project apart?
+
+*Give some reasons why this game is not like every other game out there. Whether the learning objective is unique, the gameplay mechanics are new, or what. You should persuade the reader that your game is novel and worthy of development. Consider arguments that would be persuasive to a Venture Capitalist, Teacher, or Researcher. These might be focused on learning needs, too.*
+
+- *It is unique*
+- *Educational while still being fun*
+- *Most coding or systems-based assignments are the same or throw you in headfirst. This will visualize the learning curve and shorten said curve*
+
+# Player Interaction Patterns and Modes
+
+## Player Interaction Pattern
+
+*People will play our game using keyboard and mouse on a browser. There will only be one player involved at once.*
+
+## Player Modes
+
+*Your game has one or more player modes. Describe each discrete mode, considering things like menus too. Generally describe the transitions between modes too.*
+
+- *Single Player Mode*: *A player will be able to access a folder menu that allows them to understand all of the different characters available, different abilities offered in the game, what level you are on, etc.*
+- *Battle Board Menu*: *This menu is where *
+- *etc.*
+
+# Gameplay Objectives
+
+- *Protect the castle*:
+    - Description: *The player must place allies to protect against the waves of enemies *
+    - Alignment: *This aligns with learning how to adapt and work  under pressure*
+- *Navigate the “Book”*:
+    - Description: *The player must use Unix commands to navigate the “Book” to pick out their allies*
+    - Alignment: *This follows the learning objective of learning Unix commands*
+
+# Procedures/Actions
+
+*The player will type Unix commands (turning the pages) to place allies to protect the castle *
+
+# Rules
+
+If the player types in an incorrect or currently unknown Unix command the book will flash red 
+*What resources are available to the player that they make use of?  How does this affect gameplay? How are these resources finite?*
+
+# Objects/Entities
+
+*We will have to design the board and some sort of terminal implementation*
+
+## Core Gameplay Mechanics (Detailed)
+
+- *Zombie Wave Defense*: *The game challenges players with progressively tougher waves of “zombies.” The idea is a “zombie” wave of defense. The different types of zombies require the player to adapt their strategy by choosing different plants and placements of those plants to handle the wave of zombies. The idea is that players should anticipate and plan out their defense to beat the wave. *
+- *Plant Placement and Resource Management:*: *Strategically placing different types of “plants” on the board to defend against the wave of zombies trying to get past your defense. Each plant has unique abilities that are good for defending against certain zombies or waves of zombies. Players must manage their resources to strategically have good defense throughout their progression. Deciding which plants to place before each wave is a core mechanic of the game. *
+- *Progression and Unlocking New Plants*: *As you progress in the game you will unlock new plants/characters that will aid you in defeating the waves of zombies. The progression mechanic will encourage users to create new strategies and find different ways to defeat the waves of zombies. *
+
+
+## Feedback
+
+*Explicitly describe what visual/audio/animation indicators there are that give players feedback on their progress towards their gameplay objectives (and ideally the learning objectives): A player will know how they are doing in terms of their learning objective because they will have to use UNIX commands to progress in the game. The further they make it into the game the more “reps” they will have with UNIX command built into the game. The more they play the more the commands are being reinforced into their brain.*
+
+*Describe what longer-term feedback you detect and give that guides the player in their learning and lets them know how they are doing in regard to the learning objectives: The player will know how they are doing in regard to the learning objectives when they are seamlessly navigating our commands. This will help the player translate their learned understanding into a real Linux environment.*
+
+# Story and Gameplay
+
+## Presentation of Rules
+
+*The player will learn the game mechanics by being presented with a tutorial (level 0) which allows them to experiment with the game and its mechanics. They will also be introduced to a cheat sheet which will help them understand the built-in UNIX-like commands that they will need to use in the game.*
+
+## Presentation of Content
+
+*Briefly describe how the player will be taught the core material they are meant to learn: The player will be taught the core material by being forced to use UNIX-like commands that will help them familiarize themselves with real UNIX commands and other concepts related to the topic. *
+
+## Story (Brief)
+
+*The Summary or TL;DR version of below*
+
+## Storyboarding
+
+*Go into as much detail as needs be to visually convey the Dynamics of your game. Be detailed. Create storyboards and freeze frame images that concisely capture important key elements of your game. You are strongly recommended to sketch pictures on paper and embed them here. Be sure make it clear how previously-described mechanics come through in the dynamics.*
+
+# Assets Needed
+
+## Aethestics
+
+*Give a sense of the aesthetics of your game, the spirit and atmosphere: In this game, gardens are transformed into battlefields where magical plants, inspired by D&D characters, defend against a zombie invasion. The setting mixes a touch of fantasy with light-hearted horror, creating a unique backdrop for strategy and action. It's a straightforward yet engaging world where players navigate through challenges with strategy and a bit of humor.*
+
+## Graphical
+
+- Characters List
+  - *Mage character*
+  - *Wizard Character*
+  - *Zombies Characters*
+- Textures:
+  - *Dungeon textures*
+  - *Zombie Textures*
+  - *...*
+- Environment Art/Textures:
+  - *DnD like battlefields*
+
+
+## Audio
+
+
+*Game region/phase/time are ways of designating a particularly important place in the game.*
+
+- Music List (Ambient sound)
+  - *Zombie Phase*: *Dark advancing music*
+  - *Buying Phase*: *Relax ambient music*
+*Game Interactions are things that trigger SFX, like character movement, hitting a spiky enemy, collecting a coin.*
+
+- Sound List (SFX)
+  - *Hitting a zombie*: *OOF sound*, *hurt sounds*
+  - *Buying a character*: *satisfaction sound*
+  - *Placing a character*: *satisfaction sound*
+  - *Correct UNIX-like command*: *satisfaction sound*
+
+
+# Metadata
+
+* Template created by Austin Cory Bart <[email protected]>, Mark Sheriff, Alec Markarian, and Benjamin Stanley.
+* Version 0.0.3
+
+

src/objects/characterSkeleton.ts

@@ -0,0 +1,36 @@
+/*
+import Phaser from "phaser";
+
+abstract class GameCharacter {
+  name: string;
+  health: number;
+  position: Phaser.Math.Vector2;
+  alive: boolean;
+  cost: number;
+
+  constructor(name: string, health: number, position: Phaser.Math.Vector2, cost: number) {
+    this.name = name;
+    this.health = health;
+    this.position = position;
+    this.alive = true;
+    this.cost = cost;
+  }
+
+  abstract attack(): void;
+
+  // Method for the character to take damage. Reduces health and checks for death.
+  takeDamage(damage: number): void {
+    this.health -= damage;
+    if (this.health <= 0) {
+      this.health = 0;
+      this.alive = false;
+      this.remove();
+    }
+  }
+
+  // Method to remove the character from the game, e.g., when health is 0.
+  remove(): void {
+    console.log(`${this.name} has been removed from the game.`);
+  }
+}
+*/

src/scenes/mainScene.ts

@@ -1,5 +1,5 @@
 import Phaser from "phaser";
-import PhaserLogo from "../objects/phaserLogo";
+//import PhaserLogo from "../objects/phaserLogo";
 import FpsText from "../objects/fpsText";
 
 export default class MainScene extends Phaser.Scene {
@@ -10,7 +10,23 @@ export default class MainScene extends Phaser.Scene {
     }
 
     create() {
-        new PhaserLogo(this, this.cameras.main.width / 2, 0);
+        this.add.image(700, 400, "grass");
+        this.add.image(1100, 400, "grass");
+        let train = this.add.image(5, 300, "trainGrounds");
+        train.flipX = true;
+        const graphics = this.add.graphics();
+
+        // Set the line color and alpha (opacity)
+        graphics.lineStyle(2, 0x000000, 1); // Black color with opacity 1 (fully opaque)
+
+        // Draw a rectangle shape without fill
+        const rectangle = new Phaser.Geom.Rectangle(100, 200, 500, 500);
+        graphics.strokeRectShape(rectangle);
+
+        // Enable input events on the rectangle
+        graphics.setInteractive(rectangle, Phaser.Geom.Rectangle.Contains);
+
+        //new PhaserLogo(this, this.cameras.main.width / 2, 0);
         this.fpsText = new FpsText(this);
 
         const message = `Phaser v${Phaser.VERSION}`;

src/scenes/preloadScene.ts

@@ -7,6 +7,8 @@ export default class PreloadScene extends Phaser.Scene {
 
     preload() {
         this.load.image("phaser-logo", "assets/img/phaser-logo.png");
+        this.load.image("grass", "assets/img/grass.png");
+        this.load.image("trainGrounds", "assets/img/trainGrounds.png");
     }
 
     create() {