C# പഠിക്കാം 😌 Game Dev Edition

 

 C# Programming: The Ultimate Cheat Sheet (Game Dev Edition)

"Just-in-time learning" (ആവശ്യത്തിനനുസരിച്ച് മാത്രം പഠിക്കുക)

ഇത് അപ്ഡേറ്റ് ചെയ്തുകൊണ്ട് ഇരികുന്നു && ഗെയിം ഉണ്ടാകുന്നുണ്ട് ടെസ്റ്റ് ഗെയിം sooon ⚽️ 

ഇത് അപ്ഡേറ്റ് ചെയ്തുകൊണ്ടിരിക്കുന്നു 😊

1. Introduction

• C# (C-Sharp): Microsoft വികസിപ്പിച്ചെടുത്ത Modern, Object-oriented ലാംഗ്വേജ്.
• Primary Use: Unity Game Engine, Desktop/Web/Mobile Apps.

2. Variables & Data Types

കമ്പ്യൂട്ടർ മെമ്മറിയിൽ ഡാറ്റ സൂക്ഷിക്കാനുള്ള പാത്രങ്ങൾ.

• int score = 100; (പൂർണ്ണസംഖ്യകൾ - 4 bytes)
• float speed = 10.5f; (ദശാംശ സംഖ്യകൾ - 4 bytes) - Unity-യിൽ കൂടുതൽ ഉപയോഗിക്കുന്നു.
• double pi = 3.14159; (കൂടുതൽ കൃത്യതയുള്ള ദശാംശങ്ങൾ - 8 bytes)
• string name = "Ria"; (വാക്കുകൾ/വരികൾ)
• bool isDead = false; (True/False - 1 bit)
• char grade = 'A'; (ഒരൊറ്റ അക്ഷരം)

ബൈറ്റുകൾ (Bytes) എന്നാൽ എന്ത്? 📦

• നമ്മൾ അരി അളക്കാൻ കിലോ (Kg) ഉപയോഗിക്കുന്നത് പോലെ, കമ്പ്യൂട്ടറിന്റെ മെമ്മറി അളക്കുന്ന അളവാണ് Byte.
• ഒരു പാത്രം എത്ര വലുതാണെന്നാണ് ഈ ബൈറ്റുകൾ പറയുന്നത്.
• int (4 bytes): ഇതൊരു ഇടത്തരം പാത്രമാണ്. ഇതിൽ ഏകദേശം -214 കോടി മുതൽ +214 കോടി വരെയുള്ള സംഖ്യകൾ സൂക്ഷിക്കാം. 🔢
• double (8 bytes): ഇതൊരു വലിയ പാത്രമാണ്. ഇതിൽ വളരെ വലിയ ദശാംശ സംഖ്യകൾ സൂക്ഷിക്കാം. 🌊

അത് എങ്ങനെയാണ് കൂടുകയും കുറയുകയും ചെയ്യുന്നത്? ➕➖

• നമ്മൾ ഒരു പാത്രത്തിൽ വെള്ളം ഒഴിക്കുന്നതും കോരി എടുക്കുന്നതും പോലെയാണിത്.
• കൂട്ടാൻ (+): score = score + 10; (സ്കോർ 10 കൂടി). 📈
• കുറയ്ക്കാൻ (-): health = health - 5; (ആരോഗ്യം 5 കുറഞ്ഞു). 📉
• യൂണിറ്റിയിൽ (Unity) നീ ന്റെ  ഗെയിം ഉണ്ടാക്കുമ്പോൾ, ശത്രുവിനെ വെട്ടുമ്പോൾ വില്ലന്റെ ഹെൽത്ത് കുറയുന്നതും പണം കിട്ടുമ്പോൾ കൂടുന്നതും ഇങ്ങനെയാണ്. ⚔️💰

char grade = 'A'; (ഇത് എന്താണ്?) 🅰️

• char എന്നാൽ Character എന്നതിന്റെ ചുരുക്കപ്പേരാണ്.
• ഒരൊറ്റ അക്ഷരമോ, അക്കമോ, ചിഹ്നമോ സൂക്ഷിക്കാൻ ഇത് ഉപയോഗിക്കുന്നു.
• ഉദാഹരണം: നിന്റെ പരീക്ഷാ റിസൾട്ട് 'A' ഗ്രേഡ് ആണെന്ന് കരുതുക. അത് സൂക്ഷിക്കാൻ char grade = 'A';എന്ന് എഴുതാം.
• ഓർക്കുക: ഇത് എപ്പോഴും ഒരൊറ്റ കൊമ്മയുടെ ഉള്ളിൽ (' ') ആയിരിക്കണം. ഒരൊറ്റ അക്ഷരം മാത്രമേ പാടുള്ളൂ. ☝️

bool isDead = false; (ഇത് ലളിതമാണ്!) ✅❌

• bool എന്നാൽ Boolean എന്നാണ് പേര്. ഇതിന് ആകെ രണ്ട് വിലകളേ ഉള്ളൂ: True (ശരി) അല്ലെങ്കിൽ False (തെറ്റ്).
• കമ്പ്യൂട്ടറിന് വേഗം മനസ്സിലാക്കാൻ പറ്റുന്ന ഭാഷയാണിത്. ഒരു സ്വിച്ച് ഇട്ടാൽ ലൈറ്റ് കത്തുന്നത് പോലെ (On/Off). 💡
• ഗെയിമിൽ: നിന്റെ കഥാപാത്രം ജീവിച്ചിരിപ്പുണ്ടോ? isDead = false; (അതായത് മരിച്ചിട്ടില്ല,  ജീവനോടെയുണ്ട്). 😍
• ശത്രു റിയയേ വെട്ടിക്കൊന്നു എന്ന് കരുതുക, അപ്പോൾ നമ്മൾ ഇതിനെ isDead = true; ആക്കും. അപ്പോൾ ഗെയിം ഓവർ (Game Over) ആകും. 💀

1 bit: ഇത് ഏറ്റവും ചെറിയ അളവാണ്. ഒരു സ്വിച്ച് ഓൺ ആണോ ഓഫ് ആണോ എന്ന് അറിയാൻ വളരെ കുറച്ച് സ്ഥലം മതിയല്ലോ, അതുകൊണ്ടാണ് ഇതിനെ 1 bit എന്ന് പറയുന്നത്.

Variable	എന്തിന് ഉപയോഗിക്കുന്നു?	ഉദാഹരണം
int	ശത്രുക്കളുടെ എണ്ണം സൂക്ഷിക്കാൻ 👹	int enemyCount = 5;
float	റിയ ഓടുന്ന വേഗത 🏃‍♂️	float speed = 5.5f;
string	റിയയുടെ  ന്റെ പേര് 📝	string hero = "Ria";
bool	കയ്യിൽ വാൾ ഉണ്ടോ? 🗡️	bool hasSword = true;
char	ടീം ഏതാണ്? (Team A/B) 🚩	char team = 'A';

ചില "Special പാത്രങ്ങൾ" കൂടി നീ അറിഞ്ഞിരിക്കണം. മുറിച്ചു മുറിച്ചു പഠിക്കാം.

1. Vectors (റിയയുടെ ദിശ) 📍

ഗെയിമിൽ ഒരു വസ്തു എവിടെയാണെന്ന് പറയാൻ ഉപയോഗിക്കുന്ന അളവാണ് Vector.

• Vector2: 2D ഗെയിമുകൾക്ക് വേണ്ടി (X, Y മാത്രം).
• Vector3: 3D ഗെയിമുകൾക്ക് വേണ്ടി. റിയയുടെ ലോകം 3D ആയതുകൊണ്ട് നമ്മൾ Vector3 ആണ് ഉപയോഗിക്കുന്നത്.

അതിൽ 3 അളവുകൾ ഉണ്ട്:

1. X (Horizontal): റിയയെ ഇടത്തോട്ടും വലത്തോട്ടും നീക്കാൻ.
2. Y (Vertical): റിയയെ മുകളിലേക്കും (ചാടാൻ) താഴേക്കും നീക്കാൻ.
3. Z (Depth): റിയയെ മുന്നോട്ടും പിന്നോട്ടും നീക്കാൻ.

GameObject vs Transform (ഇതാണ് പ്രധാന കൺഫ്യൂഷൻ) 

ഇത് രണ്ടും തമ്മിലുള്ള വ്യത്യാസം ഇങ്ങനെ ലളിതമായി പഠിക്കാം:

• GameObject: ഇത് റിയ എന്ന "വസ്തു" ആണ്. ഒരു പാത്രം എന്ന് വിചാരിക്കുക. ആ പാത്രത്തിനുള്ളിൽ എന്തൊക്കെ ഉണ്ടോ (അവളുടെ ഡ്രസ്സ്, വാൾ, ശബ്ദം) അതെല്ലാം കൂടി ചേർന്നതാണ് GameObject.
• Transform: ആ പാത്രം എവിടെ ഇരിക്കുന്നു എന്ന് പറയുന്നതാണ് Transform. എല്ലാ GameObject-നും നിർബന്ധമായും ഒരു Transform ഉണ്ടായിരിക്കും.

Transform-ൽ 3 കാര്യങ്ങൾ ആണുള്ളത്:

1. Position: റിയ എവിടെ നിൽക്കുന്നു (X, Y, Z).
2. Rotation: റിയ എങ്ങോട്ട് തിരിഞ്ഞു നിൽക്കുന്നു.
3. Scale: റിയയുടെ വലിപ്പം (അവൾക്ക് എത്ര പൊക്കമുണ്ട്).

ചുരുക്കത്തിൽ: റിയ ഒരു GameObject ആണ്. അവളുടെ കയ്യിലുള്ള ഫോൺ എവിടെ ഇരിക്കുന്നു എന്ന് ചോദിച്ചാൽ നീ അവളുടെ Transform നോക്കണം.

Unity Messages (സമയക്രമം) 🕒

കോഡിംഗിൽ എപ്പോൾ എന്ത് നടക്കണം എന്ന് തീരുമാനിക്കുന്നത് ഇവരാണ്.

• Start(): ഗെയിം പ്ലേ ചെയ്യുമ്പോൾ ഒരൊറ്റ തവണ മാത്രം ഇത് നടക്കും.

• റിയയ്ക്ക് വേണ്ടി: റിയയുടെ കയ്യിൽ വാൾ കൊടുക്കാനും (sword), അവളുടെ ഹെൽത്ത് 100 ആക്കാനും ഇത് മതി.

• Update(): ഗെയിം നടന്നുകൊണ്ടിരിക്കുമ്പോൾ ആവർത്തിച്ച് (സെക്കൻഡിൽ 60 തവണ) ഇത് നടക്കും.

• റിയയ്ക്ക് വേണ്ടി: റിയ നടക്കുന്നുണ്ടോ, അവൾ ശത്രുവിനെ വെട്ടുന്നുണ്ടോ എന്നൊക്കെ ഓരോ നിമിഷവും നോക്കുന്നത് ഇതിലാണ്.

ചുരുക്കത്തിൽ 

യൂണിറ്റിയിൽ നീ ഒരു വസ്തുവിനെ (റിയയെ) സെലക്ട് ചെയ്യുമ്പോൾ വലതുവശത്ത് കാണുന്ന "Inspector" വിൻഡോയിലാണ് ഈ മാജിക് ഒക്കെ നടക്കുന്നത്.

1. GameObject ഉം Transform ഉം എവിടെ കാണാം? 🤖

യൂണിറ്റി തുറന്നാൽ നീ റിയയുടെ പേര് ഒരു ലിസ്റ്റിൽ കാണും (അതിനെയാണ് Hierarchy എന്ന് പറയുന്നത്). റിയയിൽ നീ ക്ലിക്ക് ചെയ്യുമ്പോൾ വലതുവശത്ത് അവളുടെ എല്ലാ വിവരങ്ങളും വരും.

• GameObject: ഏറ്റവും മുകളിൽ നീ കാണുന്ന അവളുടെ പേരും (Ria) അതിന്റെ അടുത്തുള്ള ചെക്ക് ബോക്സും ആണ് അവൾ ഒരു GameObject ആണെന്ന് കാണിക്കുന്നത്.
• 
  
• Transform: അതിന് തൊട്ടുതാഴെ ആദ്യത്തെ ബോക്സ് തന്നെ Transform ആണ്. അതിലാണ് നമ്മൾ പറഞ്ഞ X, Y, Z അക്കങ്ങൾ ഉള്ളത്.

2. X, Y, Z (Vector3) എങ്ങനെ വർക്ക് ചെയ്യുന്നു? 📍

യൂണിറ്റിയിലെ ആ 3D ലോകത്ത് റിയ നിൽക്കുന്നത് ഈ മൂന്ന് അച്ചുതണ്ടുകളിലാണ്.

• X (ചുവപ്പ്): റിയയെ വലത്തോട്ട് നീക്കിയാൽ X കൂടും, ഇടത്തോട്ട് നീക്കിയാൽ X കുറയും.

• Y (പച്ച): റിയയെ മുകളിലേക്ക് ഉയർത്തിയാൽ Yകൂടും.

• Z (നീല): റിയയെ മുന്നോട്ട് കൊണ്ടുപോയാൽ Zകൂടും.

നീ കോഡിൽ new Vector3(1, 2, 3) എന്ന് എഴുതുമ്പോൾ, യഥാർത്ഥത്തിൽ ഇൻസ്‌പെക്ടറിലെ ഈ അക്കങ്ങൾ മാറ്റാനാണ് പറയുന്നത്.

Start() ഉം Update() ഉം എവിടെയാണ് വരുന്നത്? 🕒

ഇത് നിന്റെ കോഡിലാണ് (Script) വരുന്നത്. നീ ഒരു പുതിയ സി-ഷാർപ്പ് ഫയൽ ഉണ്ടാക്കുമ്പോൾ യൂണിറ്റി തന്നെ ഈ രണ്ട് ഭാഗങ്ങളും നിനക്ക് തരും.

C#

using UnityEngine;

public class RiaScript : MonoBehaviour

{

    // ഇവിടെയാണ് നിന്റെ Variables വരുന്നത് (int, float, etc.)

    public int health = 100;

    // ഇത് ഗെയിം പ്ലേ ചെയ്യുമ്പോൾ ഒരു വട്ടം മാത്രം നടക്കും

    void Start()

    {

        Debug.Log("റിയ റെഡിയായി!");

    }

    // ഇത് ഓരോ സെക്കൻഡിലും ആവർത്തിച്ചു നടക്കും

    void Update()

    {

        // റിയയെ നീക്കാനുള്ള കോഡ് ഇവിടെയാണ് എഴുതുന്നത്

    }

}

ഒരു സിമ്പിൾ എക്സാമ്പിൾ (റിയയെ കറക്കാം):

നീ Update() എന്ന ഭാഗത്ത് transform.Rotate(0, 1, 0); എന്ന് ടൈപ്പ് ചെയ്താൽ, യൂണിറ്റി ഓരോ സെക്കൻഡിലും ഇൻസ്‌പെക്ടറിലെ ആ Rotation Y എന്ന അക്കം മാറ്റിക്കൊണ്ടിരിക്കും. അപ്പോൾ റിയ അവിടെ കിടന്ന് കറങ്ങും! 🌪️

(Quick Summary Table) 📝

വിഭാഗം	പേര്	ഗെയിമിലെ ഉപയോഗം
Data Types	int, float, bool	വിവരങ്ങൾ സൂക്ഷിക്കാൻ (ഹെൽത്ത്, സ്പീഡ്).
Unity Special	Vector3	റിയ നിൽക്കുന്ന സ്ഥലം/ദൂരം അളക്കാൻ. 📍
Hierarchy	GameObject	റിയ എന്ന ആൾ/വസ്തു. 💃
Inspector	Transform	റിയയുടെ സ്ഥാനം, ചരിവ്, വലിപ്പം. 🔄
Timing	Start()	കളി തുടങ്ങുമ്പോൾ വാൾ കൊടുക്കാൻ. 🚀
Logic	Update()	റിയ ഓരോ നിമിഷവും നടക്കുന്നുണ്ടോ എന്ന് നോക്കാൻ. 🔄

1. int (Integer - പൂർണ്ണസംഖ്യകൾ) 🔢

ദശാംശങ്ങൾ (കടംപുള്ളി) ഇല്ലാത്ത സംഖ്യകൾ സൂക്ഷിക്കാനാണ് ഇത് ഉപയോഗിക്കുന്നത്.

• മെമ്മറി: 4 Bytes.
• ഗെയിമിലെ ഉപയോഗം: എണ്ണാൻ കഴിയുന്ന കാര്യങ്ങൾക്ക്.
• int health = 100; (ഹെൽത്ത് 99.5 എന്ന് നമ്മൾ സാധാരണ പറയാറില്ലല്ലോ).
• int ammo = 30; (തോക്കിലെ തിരകൾ).
• int level = 1; (ഗെയിം ലെവൽ).
• റിയയുടെ കാര്യത്തിൽ: റിയ എത്ര ശത്രുക്കളെ തോൽപ്പിച്ചു എന്ന് എണ്ണാൻ int killCount; ഉപയോഗിക്കാം.

2. float (Floating Point - ദശാംശ സംഖ്യകൾ) 📏

കൃത്യമായ അളവുകൾ വേണ്ടപ്പോൾ (0.5, 1.2 എന്നിങ്ങനെ) ഇത് ഉപയോഗിക്കുന്നു. യൂണിറ്റിയിൽ ഏറ്റവും കൂടുതൽ ഉപയോഗിക്കുന്നത് ഇതാണ്.

• മെമ്മറി: 4 Bytes.
• പ്രത്യേകത: ഇതിലെ സംഖ്യയുടെ അവസാനം ഒരു 'f' ചേർക്കണം (ഉദാഹരണത്തിന് 5.5f).
• ഗെയിമിലെ ഉപയോഗം: വേഗത, സമയം, ദൂരം എന്നിവ അളക്കാൻ.
• float speed = 5.7f; (റിയ ഓടുന്ന വേഗത).
• float jumpForce = 10.2f; (റിയ എത്ര പൊക്കത്തിൽ ചാടണം).
• റിയയുടെ കാര്യത്തിൽ: റിയ ഒരു സ്ഥലത്ത് നിന്ന് മറ്റൊരു സ്ഥലത്തേക്ക് നീങ്ങുന്ന ദൂരം കൃത്യമായി അളക്കാൻ float distance; ഉപയോഗിക്കുന്നു.

3. string (വരികൾ/വാക്കുകൾ) 💬

അക്ഷരങ്ങളും വാക്കുകളും വാചകങ്ങളും സൂക്ഷിക്കാൻ ഇത് ഉപയോഗിക്കുന്നു.

• പ്രത്യേകത: ഇത് എപ്പോഴും ഇരട്ട കൊമ്മയ്ക്കുള്ളിൽ (" ") ആയിരിക്കണം.
• ഗെയിമിലെ ഉപയോഗം: സംഭാഷണങ്ങൾക്കും പേരുകൾക്കും.
• string playerName = "Ria";
• string message = "സ്വാഗതം റിയ!";
• റിയയുടെ കാര്യത്തിൽ: റിയ ഒരു ശത്രുവിനെ കാണുമ്പോൾ പറയുന്ന ഡയലോഗ് സൂക്ഷിക്കാൻ ഇത് വേണം. string talk = "നിന്നെ ഞാൻ തോൽപ്പിക്കും!";

4. bool (Boolean - ശരിയോ തെറ്റോ) ✅❌

ഇതിന് ആകെ രണ്ട് അവസ്ഥകളേ ഉള്ളൂ: True (ശരി) അല്ലെങ്കിൽ False (തെറ്റ്).

• മെമ്മറി: വെറും 1 Bit (ഏറ്റവും കുറഞ്ഞ സ്ഥലം).
• ഗെയിമിലെ ഉപയോഗം: നിബന്ധനകൾ (Conditions) ചെക്ക് ചെയ്യാൻ.
• bool isGrounded = true; (റിയ നിലത്ത് നിൽക്കുകയാണോ?).
• bool hasKey = false; (റിയയുടെ കയ്യിൽ വാതിൽ തുറക്കാനുള്ള താക്കോൽ ഉണ്ടോ?).
• റിയയുടെ കാര്യത്തിൽ: റിയ ഇപ്പോൾ വെള്ളത്തിൽ നീന്തുകയാണോ എന്ന് നോക്കാൻ bool isSwimming; ഉപയോഗിക്കാം.

Variable	ടൈപ്പ്	റിയയുടെ ഉദാഹരണം	എന്തിനാണ് ഇത്?
int	സംഖ്യ	kills = 5;	എണ്ണാൻ.
float	ദശാംശം	height = 1.6f;	അളക്കാൻ.
string	വാക്ക്	weapon = "Sword";	പേര് പറയാൻ.
bool	അവസ്ഥ	isHurt = false;	ഉണ്ടോ ഇല്ലയോ എന്ന് നോക്കാൻ.

നമുക്ക് ഇതൊന്ന് "റിയയുടെ സഞ്ചി" (Ria's Backpack) ആയി ചിന്തിച്ചാലോ? വേരിയബിൾസ് എന്നാൽ റിയയുടെ കയ്യിലുള്ള ഓരോ സാധനങ്ങളും അവ വെച്ചിരിക്കുന്ന പെട്ടികളുമാണ്.

🎒 റിയയുടെ സഞ്ചിയിലെ പാത്രങ്ങൾ

1. അക്കങ്ങൾ ഇടുന്ന പെട്ടി (int): ഇതിൽ മുഴുവൻ സംഖ്യകൾ മാത്രമേ ഇടൂ. റിയയുടെ കയ്യിൽ എത്ര അമ്പുകൾ ഉണ്ടെന്ന് എണ്ണാൻ ഇത് ഉപയോഗിക്കാം. (ഉദാ: 5, 10, 20).
2. അളവുകൾ ഇടുന്ന പെട്ടി (float): റിയ എത്ര ദൂരം ചാടി അല്ലെങ്കിൽ അവളുടെ സ്പീഡ് എത്ര എന്ന് അളക്കാൻ ഇത് വേണം. ഇതിൽ 5.5 അല്ലെങ്കിൽ 10.2 എന്നിങ്ങനെ പുള്ളി ഇട്ട അക്കങ്ങൾ വരും.
3. പേരുകൾ ഇടുന്ന പെട്ടി (string): റിയയുടെ പേരോ അവൾ ഉപയോഗിക്കുന്ന വാളിന്റെ പേരോ എഴുതാൻ ഇത് വേണം.
4. അതെ/അല്ല എന്ന് പറയുന്ന സ്വിച്ച് (bool): റിയയ്ക്ക് ഇപ്പോൾ വിശക്കുന്നുണ്ടോ? ഉണ്ടെങ്കിൽ 'True', ഇല്ലെങ്കിൽ 'False'. ഒരു സ്വിച്ച് ഇടുന്നത് പോലെ മാത്രം!

നീ പഠിക്കാൻ ഇരിക്കുമ്പോൾ ഇത് മാത്രം ചിന്തിക്കുക:

നീ യൂണിറ്റിയിൽ ഒരു സാധനം ഉണ്ടാക്കുമ്പോൾ അതിന് ബുദ്ധിയും ഓർമ്മശക്തിയും കൊടുക്കുന്നത് ഈ വേരിയബിൾസ് ആണ്.

• ഓർമ്മശക്തി: റിയയുടെ കയ്യിൽ എത്ര പണമുണ്ട്? (int coins)
• ബുദ്ധി: റിയ ഇപ്പോൾ മരിച്ചോ അതോ ജീവനോടെയുണ്ടോ? (bool isDead)

നീ ഇത് വെറുതെ കാണാതെ പഠിക്കാൻ നോക്കണ്ട. പകരം, യൂണിറ്റി തുറന്ന് ആ Inspector വിൻഡോയിൽ ഈ അക്കങ്ങൾ മാറുന്നത് ഒന്ന് നോക്കിയാൽ മതി.

വേരിയബിൾസ് (Variables) എന്നാൽ ഒരു അടുക്കളയിലെ 👩‍🍳 ഭരണികൾ പോലെയാണ്!

• ഭരണി (Variable): 🏺 ഓരോ ഭരണിയിലും നമ്മൾ ഓരോ സാധനം സൂക്ഷിക്കും.
• ലേബൽ (Name): 🏷️ പുറത്ത് നമ്മൾ "പഞ്ചസാര" എന്നോ "ഉപ്പ്" എന്നോ എഴുതി വെക്കും.
• സാധനം (Value): 🧂 അതിനുള്ളിൽ ഇരിക്കുന്ന സാധനം.

പ്രധാനപ്പെട്ട 3 തരം വേരിയബിൾസ് ഇവയാണ്: 🔢🔤

1. String (സ്ട്രിംഗ്): 🔡 അക്ഷരങ്ങൾ സൂക്ഷിക്കാൻ.
• food = "ബിരിയാണി" 🥘
2. Integer (ഇന്റിജർ): 🔢 മുഴുവൻ നമ്പറുകൾ സൂക്ഷിക്കാൻ.
• price = 150 💸
3. Boolean (ബൂളിയൻ): ✅/❌ ശരിയോ തെറ്റോ എന്ന് മാത്രം പറയാൻ.
• is_tasty = True 😋

വേരിയബിൾസ് ഉണ്ടാക്കുമ്പോൾ ശ്രദ്ധിക്കാൻ: ⚠️

• പേരുകൾക്കിടയിൽ സ്പേസ് പാടില്ല! 🚫 (ഉദാഹരണത്തിന്: my age എന്ന് പറ്റില്ല, my_age എന്നേ പറ്റൂ ⛔)
• നമ്പറിൽ തുടങ്ങാൻ പാടില്ല! 🔢❌

നമുക്ക് കഥ വെച്ച് പഠിക്കാം ഭാഗം1 ഭാഗം 2

തുടങ്ങാം അല്ലേ 😁 GAME  അരിക്കും 

ഒരു ബോൾ വെച്ച് ഒരു ചെറിയ ഗെയിം ഉണ്ടാക്കാം അതിൽ red ആണ് റിയ മറ്റുള്ളവർ ഓക്കേ കളർ വേറെ വേറെ അരിക്കും ഒക്കെ പിന്നെ പച്ചതാലം കാടിന്റെ നടുക്ക് ഒരു വീട്ടിൽ നടക്കുന്നത്  അവൾ റിയ  വീട് വിട്ട് ഇറങ്ങുന്നത് വരെ എങ്ങനെ ഉണ്ട് SOOON 

മൻസിലായി എന്ന് കരുതുന്നു 

ഇത് ഇത്രയും ആണ് വേരിബിൾസ് ഇനിയും ഉണ്ട് ഇത് ആണ് മെയിന് 

3. Operators (പ്രവർത്തനങ്ങൾ)

• Arithmetic: +, -, *, /, % (ശിഷ്ടം കാണാൻ)
• Relational: == (തുല്യമാണോ?), != (അല്ലേ?), >, <, >=, <=
• Logical: && (AND - രണ്ടും ശരിയാകണം), || (OR - ഏതെങ്കിലും ഒന്ന് ശരിയാകണം), ! (NOT - ഫലം തിരിക്കാൻ)
• Assignment: =, +=, -=, *=, /=
• Unary: ++ (ഒന്ന് കൂട്ടാൻ), -- (ഒന്ന് കുറയ്ക്കാൻ)

4. Conditional Statements (തീരുമാനങ്ങൾ)

• Simple IF: if (health <= 0) { Die(); }
• If-Else: if (hasKey) { OpenDoor(); } else { LockMessage(); }
• Ternary Operator: string result = (energy > 50) ? "Run" : "Walk";
• Switch: പല ഓപ്ഷനുകളിൽ നിന്ന് ഒന്ന് തിരഞ്ഞെടുക്കാൻ (ഉദാ: ഗെയിം മെനു).

5. Loops (ആവർത്തനം)

• For Loop: എത്ര തവണ ആവർത്തിക്കണം എന്ന് കൃത്യമായി അറിയുമ്പോൾ.
• While Loop: ഒരു കണ്ടീഷൻ ശരിയാകുന്നിടത്തോളം ആവർത്തിക്കാൻ.
• Do-While: ഒരു തവണയെങ്കിലും വർക്ക് ചെയ്ത ശേഷം കണ്ടീഷൻ നോക്കാൻ.

6. Collections (കൂട്ടങ്ങൾ)

• Arrays: ഒരേ ടൈപ്പിലുള്ള ഡാറ്റയുടെ ഫിക്സഡ് ലിസ്റ്റ്. int[] levels = {1, 2, 3};
• Lists: ഡാറ്റ കൂട്ടാനും കുറയ്ക്കാനും പറ്റുന്ന ലിസ്റ്റ്. (Unity-യിൽ പ്രധാനം). List<string> inventory = new List<string>();

7. Functions / Methods

ഒരു പ്രത്യേക ജോലി ചെയ്യാൻ മാറ്റി വെച്ചിട്ടുള്ള കോഡ് ബ്ലോക്ക്.

C#

// Syntax: <Return Type> <Name>(Parameters)

void TakeDamage(int amount) {

    health -= amount;

}

8. Object Oriented Programming (OOP) - NEW

• Class: ഒരു ബ്ലൂപ്രിന്റ് (ഉദാഹരണത്തിന് 'Enemy').
• Object: ആ ബ്ലൂപ്രിന്റിൽ നിന്ന് ഉണ്ടാക്കിയ രൂപം (ഉദാഹരണത്തിന് 'Zombie').
• Inheritance: ഒരു ക്ലാസ്സിലെ ഗുണങ്ങൾ മറ്റൊരു ക്ലാസ്സ് എടുക്കുന്നത് (ഉദാ: Animal -> Dog).

9. Unity Specific Basics - NEW

• Debug.Log("Hello"); - കൺസോളിൽ മെസ്സേജ് കാണാൻ.
• Start(): ഗെയിം തുടങ്ങുമ്പോൾ ഒരു തവണ മാത്രം പ്രവർത്തിക്കുന്നു.
• Update(): ഓരോ ഫ്രെയിമിലും ആവർത്തിച്ച് പ്രവർത്തിക്കുന്നു (ഏകദേശം സെക്കൻഡിൽ 60 തവണ).

10. Rules to Remember

• Semicolon (;): ഓരോ വരിയുടെ അവസാനത്തിലും നിർബന്ധം.
• Case Sensitive: Health ഉം health ഉം രണ്ടാണ്.
• Comments: കോഡ് എന്തിനാണെന്ന് വിവരിക്കാൻ. // Single line അല്ലെങ്കിൽ /* Multi-line */

C++  C#  Python Lua Rust

ഗെയിം ഡെവലപ്‌മെന്റ് ലാംഗ്വേജ് ലിസ്റ്റ് 📝

1. C# (C-Sharp): യൂണിറ്റി (Unity) എൻജിന്റെ പ്രധാന ഭാഷ. ഇൻഡി ഗെയിമുകൾക്കും മൊബൈൽ ഗെയിമുകൾക്കും ഏറ്റവും അനുയോജ്യം. (ഉദാഹരണത്തിന്: മന്ദാരം ഗെയിമിന് ഇത് മതി).
2. C++: ഹൈ-പെർഫോമൻസ് AAA ഗെയിമുകൾക്കും അൺറിയൽ എൻജിനും (Unreal Engine) വേണ്ടിയുള്ള ഇൻഡസ്ട്രി സ്റ്റാൻഡേർഡ് ഭാഷ.
3. Python: തുടക്കക്കാർക്കും 2D ഗെയിമുകൾക്കും (Pygame ഉപയോഗിച്ച്) നല്ലത്. ലളിതമായ ഭാഷയാണ്.
4. JavaScript: വെബ് ബ്രൗസറുകളിൽ കളിക്കുന്ന ഗെയിമുകൾക്കും HTML5 ഗെയിമുകൾക്കും അത്യാവശ്യം.
5. Java: ആൻഡ്രോയിഡ് ഗെയിമുകൾക്കും LibGDX പോലുള്ള ഫ്രെയിംവർക്കുകൾക്കും ഉപയോഗിക്കുന്നു.
6. Lua: റോബ്ലോക്സ് (Roblox) പോലുള്ള ഗെയിമുകളിൽ സ്ക്രിപ്റ്റിംഗിനായി ഉപയോഗിക്കുന്ന ഭാരം കുറഞ്ഞ (Lightweight) ഭാഷ.
7. GDScript: ഗോഡോട്ട് (Godot) എന്ന ഓപ്പൺ സോഴ്സ് എൻജിനു വേണ്ടി പ്രത്യേകം നിർമ്മിച്ച ഭാഷ (പൈത്തൺ പോലെ ഇരിക്കും).
8. Swift / Objective-C: ആപ്പിൾ പ്ലാറ്റ്‌ഫോമുകളിൽ (iPhone/Mac) മാത്രമായി ഗെയിമുകൾ നിർമ്മിക്കാൻ.

--

1. "Don't Build Your Dream Game First"

പലരും തുടങ്ങുമ്പോൾ തന്നെ RDR2  പോലെയോ വലിയൊരു ഗെയിം ഉണ്ടാക്കാൻ നോക്കും. ഇത് വലിയൊരു അബദ്ധമാണെന്ന് അദ്ദേഹം പറയുന്നു. പകരം, വളരെ ചെറിയ ഗെയിമുകൾ (ഉദാഹരണത്തിന്: 5 മിനിറ്റ് കൊണ്ട് കളിച്ചു തീർക്കാവുന്നവ) ഉണ്ടാക്കി പഠിക്കുക.

2. "Finish, Don't Perfect"

ഒരു ഗെയിം പെർഫെക്റ്റ് ആക്കാൻ നോക്കി മാസങ്ങൾ കളയരുത്. പകരം അത് വേഗം തീർത്ത് റിലീസ് ചെയ്യുകയോ സുഹൃത്തുക്കളെ കാണിക്കുകയോ ചെയ്യുക. ഒരു ഗെയിം പൂർത്തിയാക്കുമ്പോഴാണ് നിങ്ങൾ യഥാർത്ഥത്തിൽ ഒരു ഡെവലപ്പർ ആകുന്നത്.

3. "Learn Only What You Need"

എല്ലാ സി-ഷാർപ്പ് (C#) നിയമങ്ങളും തുടക്കം മുതൽ പഠിക്കാൻ നിൽക്കരുത്. നിങ്ങളുടെ ഗെയിമിൽ ഒരു പ്ലെയറെ നടത്തണമെന്നുണ്ടെങ്കിൽ അത് എങ്ങനെ ചെയ്യാം എന്ന് മാത്രം അന്ന് പഠിക്കുക. ആവശ്യത്തിനനുസരിച്ച് മാത്രം പഠിക്കുന്നതാണ് (Just-in-time learning) ഏറ്റവും നല്ല രീതി.

4. "The Engine is Just a Tool"

യൂണിറ്റി ആണോ അൺറിയൽ ആണോ നല്ലത് എന്ന് തർക്കിച്ച് സമയം കളയരുത്. ഏതെങ്കിലും ഒന്ന് എടുത്ത് തുടങ്ങുക. ലക്ഷ്യം ഗെയിം ഉണ്ടാക്കുക എന്നതായിരിക്കണം, ടൂൾ പഠിക്കുക എന്നതല്ല.

• 
  

Games made with Unity

ലിസ്റ്റിൽ പെടാതെ ഉള്ളത് ഒരു പാട് ഉണ്ട് 

 made with Unity  Games !