feat: profile unity script and data

.gitignore

@@ -1771,3 +1771,4 @@ games/unreal/BulletHellGame/BulletHellCPP/Intermediate/Build/SourceFileCache.bin
 games/unreal/BulletHellGame/BulletHellCPP/Intermediate/Build/Linux/ActionHistory.bin
 games/unreal/BulletHellGame/BulletHellCPP/Intermediate/Build/Linux/ActionHistory.bin
 games/unreal/BulletHellGame/BulletHellCPP/Intermediate/Build/SourceFileCache.bin
+*.sqlite

DAILY_CHECKLIST.md

@@ -6,9 +6,9 @@
 ## 📅 Week 1: January 16-22 - PERFORMANCE DATA COLLECTION
 
 ### Friday, January 16 (Day 1) - PASSED
-- [ ] Install/verify NVIDIA Nsight Graphics
-- [ ] Document test hardware specs (run `./scripts/get_hardware_specs.sh`)
-- [ ] Review test scenario document (`./scripts/test_scenarios.md`)
+- [x] Install/verify NVIDIA Nsight Graphics
+- [x] Document test hardware specs (run `./scripts/get_hardware_specs.sh`)
+- [x] Review test scenario document (`./scripts/test_scenarios.md`)
 
 ---
 
@@ -17,141 +17,173 @@
 
 ---
 
-### Sunday, January 18 (Day 3) ✅ TODAY
+### Sunday, January 18 (Day 3) - PASSED
 - [x] **Finish Unreal game implementation** 🎉
 
 **Achievement unlocked**: Both Unity and Unreal games ready for testing!
 
 ---
 
-### Monday, January 19 (Day 4)
-- [ ] Install/verify NVIDIA Nsight Graphics
-- [ ] Document test hardware specs (run `./scripts/get_hardware_specs.sh`)
-- [ ] Review test scenario document (`./scripts/test_scenarios.md`)
-- [ ] Run Unity game, capture 2-3 frames in Nsight
-- [ ] Run Unreal game, capture 2-3 frames in Nsight
+### Monday, January 19 (Day 4) - PASSED (incomplete)
+- [x] Install/verify NVIDIA Nsight Systems
+- [x] Document test hardware specs (run `./scripts/get_hardware_specs.sh`)
+- [x] Review test scenario document (`./scripts/test_scenarios.md`)
+- [ ] ~~Run `./scripts/close_background_apps.sh` before testing~~ → moved
+- [ ] ~~Complete ALL Unity testing (3 full 90-second runs)~~ → moved
+- [ ] ~~Save captures as `unity_run_1.nsight-rep`, `unity_run_2.nsight-rep`, `unity_run_3.nsight-rep`~~ → moved
+- [ ] ~~Take screenshots of Nsight timeline for each run~~ → moved
 
-**Goal**: Nsight working, first captures from BOTH engines
+**Goal**: All Unity performance data captured ❌ NOT ACHIEVED
 **Target hours**: 4 hours
 
 ---
 
-### Tuesday, January 20 (Day 5)
-- [ ] Complete Unity game testing (5-10 frame captures total)
-- [ ] Capture at different difficulty levels (low/medium/high bullets)
-- [ ] Complete Unreal game testing (5-10 captures total)
-- [ ] Test at equivalent difficulty levels to Unity
-- [ ] Document any differences in testing approach
+### Tuesday, January 20 (Day 5) - PASSED (skipped)
+- [ ] ~~Run `./scripts/close_background_apps.sh` before testing~~ → moved
+- [ ] ~~Complete ALL Unreal testing (3 full 90-second runs)~~ → moved
+- [ ] ~~Save captures as `unreal_run_1.nsight-rep`, `unreal_run_2.nsight-rep`, `unreal_run_3.nsight-rep`~~ → moved
+- [ ] ~~Take screenshots of Nsight timeline for each run~~ → moved
+- [ ] ~~Document any differences observed between engines~~ → moved
 
-**Goal**: All raw testing data collected from both engines
+**Goal**: All Unreal performance data captured ❌ NOT ACHIEVED
 **Target hours**: 4 hours
 
 ---
 
-### Wednesday, January 21 (Day 6)
-- [ ] Export key metrics from Nsight (frame time, draw calls, memory)
-- [ ] Take screenshots of important Nsight views
-- [ ] Organize all captured data in spreadsheet/CSV
-- [ ] Create comparison tables (Unity vs Unreal)
-- [ ] Identify key findings from raw data
+### Wednesday, January 21 (Day 6) - PASSED (skipped)
+- [ ] ~~Export key metrics from Nsight (frame time, draw calls, memory)~~ → moved
+- [ ] ~~Take screenshots of important Nsight views~~ → moved
+- [ ] ~~Organize all captured data in spreadsheet/CSV~~ → moved
+- [ ] ~~Create comparison tables (Unity vs Unreal)~~ → moved
+- [ ] ~~Identify key findings from raw data~~ → moved
 
-**Goal**: Data organized, initial analysis done
+**Goal**: Data organized, initial analysis done ❌ NOT ACHIEVED
 **Target hours**: 4 hours
 
 ---
 
-### Thursday, January 22 (Day 7)
-- [ ] Create graph 1: Frame time comparison
-- [ ] Create graph 2: GPU utilization comparison
-- [ ] Create graph 3: Memory usage comparison
-- [ ] Create graph 4: Draw calls efficiency
-- [ ] Save all figures to latex/tex/img/
+### Thursday, January 22 (Day 7) - PASSED (skipped)
+- [ ] ~~Create graph 1: Frame time comparison~~ → moved
+- [ ] ~~Create graph 2: GPU utilization comparison~~ → moved
+- [ ] ~~Create graph 3: Memory usage comparison~~ → moved
+- [ ] ~~Create graph 4: Draw calls efficiency~~ → moved
+- [ ] ~~Save all figures to latex/tex/img/~~ → moved
 
-**✅ WEEK 1 MILESTONE**: All performance data collected and visualized
+**❌ WEEK 1 MILESTONE MISSED**: Performance data NOT collected
 **Target hours**: 4 hours
 
 ---
 
 ## 📅 Week 2: January 23-29 - WRITING & ANALYSIS
 
-### Friday, January 23 (Day 8)
-- [ ] Write Chapter 4 methodology section (test setup, tools used)
-- [ ] Write Chapter 5 Section 5.1 (Test methodology)
-- [ ] Write Chapter 5 Section 5.2 (Test scenarios)
-- [ ] Create LaTeX tables for results
-- [ ] Target: Chapter 4 done, Chapter 5 started
+### Friday, January 23 (Day 8) ✅ TODAY - CATCH-UP DAY
+**⚠️ BEHIND SCHEDULE - Need to catch up on performance testing**
 
-**Goal**: Methodology complete, results chapter started
+**PRIORITY: Complete Unity Testing (from Day 4)**
+- [x] Run `./scripts/close_background_apps.sh` before testing
+- [x] Complete Unity stationary test run
+- [x] Complete Unity dynamic test run
+- [x] Save captures as `unity_stationary.nsight-rep`, `unity_dynamic.nsight-rep`
+- [ ] Take screenshots of Nsight timeline for each run
+
+**If time permits: Start Unreal Testing (from Day 5)**
+- [ ] Complete Unreal stationary test run
+- [ ] Complete Unreal dynamic test run
+- [ ] Save captures as `unreal_stationary.nsight-rep`, `unreal_dynamic.nsight-rep`
+
+**Goal**: Get back on track - complete Unity testing minimum
 **Target hours**: 8 hours
 
 ---
 
-### Saturday, January 24 (Day 9)
-- [ ] Write Chapter 5 Section 5.3 (Results - Unity)
-- [ ] Write Chapter 5 Section 5.4 (Results - Unreal)
-- [ ] Write Chapter 5 Section 5.5 (Comparative analysis)
-- [ ] Insert all figures and tables with proper references
-- [ ] Target: Chapter 5 complete (200+ lines)
+### Saturday, January 24 (Day 9) - CATCH-UP
+**Complete Unreal Testing + Start Data Analysis**
 
-**Goal**: Chapter 5 (Performance Tests) finished
+- [ ] Run `./scripts/close_background_apps.sh` before testing
+- [ ] Complete Unreal stationary test run (if not done Friday)
+- [ ] Complete Unreal dynamic test run (if not done Friday)
+- [ ] Save captures as `unreal_stationary.nsight-rep`, `unreal_dynamic.nsight-rep`
+- [ ] Take screenshots of Nsight timeline for each run
+- [ ] Document any differences observed between engines
+- [ ] Export key metrics from Nsight (frame time, draw calls, memory)
+
+**Goal**: All performance data captured (both engines)
 **Target hours**: 8 hours
 
 ---
 
-### Sunday, January 25 (Day 10)
-- [ ] Chapter 6 Section 6.1: Graphics capabilities (Unity URP vs Unreal)
-- [ ] Chapter 6 Section 6.2: Shader systems comparison
-- [ ] Chapter 6 Section 6.3: Lighting and post-processing
-- [ ] Chapter 6 Section 6.4: Physics engine comparison
-- [ ] Integrate interview quotes where relevant
+### Sunday, January 25 (Day 10) - CATCH-UP
+**Data Analysis & Visualization**
 
-**Goal**: Half of Chapter 6 capabilities analysis done
+- [ ] Take screenshots of important Nsight views
+- [ ] Organize all captured data in spreadsheet/CSV
+- [ ] Create comparison tables (Unity vs Unreal)
+- [ ] Identify key findings from raw data
+- [ ] Create graph 1: Frame time comparison
+- [ ] Create graph 2: GPU utilization comparison
+- [ ] Create graph 3: Memory usage comparison
+- [ ] Create graph 4: Draw calls efficiency
+- [ ] Save all figures to latex/tex/img/
+
+**✅ DELAYED WEEK 1 MILESTONE**: All performance data collected and visualized
 **Target hours**: 8 hours
 
 ---
 
 ### Monday, January 26 (Day 11)
-- [ ] Chapter 6 Section 6.5: Audio systems
-- [ ] Chapter 6 Section 6.6: Animation systems
-- [ ] Chapter 6 Section 6.7: Scripting and workflow
-- [ ] Target: Chapter 6 complete (180+ lines total)
+**Chapter 4 & 5 - Methodology and Results**
 
-**Goal**: Chapter 6 finished
+- [ ] Write Chapter 4 methodology section (test setup, tools used)
+- [ ] Write Chapter 5 Section 5.1 (Test methodology)
+- [ ] Write Chapter 5 Section 5.2 (Test scenarios)
+- [ ] Write Chapter 5 Section 5.3 (Results - Unity)
+- [ ] Create LaTeX tables for results
+
+**Goal**: Chapter 4 done, Chapter 5 half done
 **Target hours**: 4 hours
 
 ---
 
 ### Tuesday, January 27 (Day 12)
-- [ ] Chapter 7 Section 7.1: Synthesis of performance results
-- [ ] Create master comparison table (all metrics)
-- [ ] Chapter 7 Section 7.2: Multi-criteria analysis
-- [ ] Create comparison matrix (performance vs features vs usability)
+**Finish Chapter 5 + Start Chapter 6**
 
-**Goal**: Results synthesis and main comparison table
+- [ ] Write Chapter 5 Section 5.4 (Results - Unreal)
+- [ ] Write Chapter 5 Section 5.5 (Comparative analysis)
+- [ ] Insert all figures and tables with proper references
+- [ ] Chapter 6 Section 6.1: Graphics capabilities (Unity URP vs Unreal)
+- [ ] Chapter 6 Section 6.2: Shader systems comparison
+
+**Goal**: Chapter 5 complete, Chapter 6 started
 **Target hours**: 4 hours
 
 ---
 
 ### Wednesday, January 28 (Day 13)
-- [ ] Chapter 7 Section 7.3: Use case recommendations
-- [ ] Chapter 7 Section 7.4: Research limitations
-- [ ] Target: Chapter 7 complete (150+ lines)
-- [ ] Start Chapter 8 conclusions
+**Finish Chapter 6**
 
-**Goal**: Chapter 7 finished, conclusions started
+- [ ] Chapter 6 Section 6.3: Lighting and post-processing
+- [ ] Chapter 6 Section 6.4: Physics engine comparison
+- [ ] Chapter 6 Section 6.5: Audio systems
+- [ ] Chapter 6 Section 6.6: Animation systems
+- [ ] Chapter 6 Section 6.7: Scripting and workflow
+- [ ] Integrate interview quotes where relevant
+
+**Goal**: Chapter 6 complete
 **Target hours**: 4 hours
 
 ---
 
 ### Thursday, January 29 (Day 14)
-- [ ] Chapter 8 Section 8.1: Main research findings
-- [ ] Answer all research questions from introduction
-- [ ] Verify hypotheses (state which confirmed/rejected)
-- [ ] Chapter 8 Section 8.2: Practical recommendations
-- [ ] Chapter 8 Section 8.3: Scientific contribution
-- [ ] Chapter 8 Section 8.4: Limitations and future work
+**Chapter 7 - Results Comparison**
 
-**✅ WEEK 2 MILESTONE**: All core chapters complete (first draft)
+- [ ] Chapter 7 Section 7.1: Synthesis of performance results
+- [ ] Create master comparison table (all metrics)
+- [ ] Chapter 7 Section 7.2: Multi-criteria analysis
+- [ ] Create comparison matrix (performance vs features vs usability)
+- [ ] Chapter 7 Section 7.3: Use case recommendations
+- [ ] Chapter 7 Section 7.4: Research limitations
+
+**Goal**: Chapter 7 complete
 **Target hours**: 4 hours
 
 ---
@@ -159,55 +191,57 @@
 ## 📅 Week 3: January 30 - February 5 - POLISH & INTEGRATION
 
 ### Friday, January 30 (Day 15)
-- [ ] Review all citations in bibliografia.bib
-- [ ] Add missing references (Unity/Unreal docs, tools)
-- [ ] Verify citation format consistency
-- [ ] Check that all bibliography entries are actually cited
-- [ ] Add DOIs where available
+**Chapter 8 - Conclusions**
 
-**Goal**: Bibliography complete and verified
+- [ ] Chapter 8 Section 8.1: Main research findings
+- [ ] Answer all research questions from introduction
+- [ ] Verify hypotheses (state which confirmed/rejected)
+- [ ] Chapter 8 Section 8.2: Practical recommendations
+- [ ] Chapter 8 Section 8.3: Scientific contribution
+- [ ] Chapter 8 Section 8.4: Limitations and future work
+
+**✅ DELAYED WEEK 2 MILESTONE**: All core chapters complete (first draft)
 **Target hours**: 8 hours
 
 ---
 
 ### Saturday, January 31 (Day 16)
+**Bibliography & Figures**
+
+- [ ] Review all citations in bibliografia.bib
+- [ ] Add missing references (Unity/Unreal docs, tools)
+- [ ] Verify citation format consistency
 - [ ] Verify all figures are in tex/img/ directory
 - [ ] Check that all figures have proper captions
 - [ ] Ensure all tables have captions above them
-- [ ] Verify all figures/tables are referenced in text
 - [ ] Polish graph aesthetics (fonts, colors, labels)
 
-**Goal**: All figures and tables publication-ready
+**Goal**: Bibliography done, figures publication-ready
 **Target hours**: 8 hours
 
 ---
 
 ### Sunday, February 01 (Day 17)
+**Appendices & Cross-references**
+
 - [ ] Create Appendix A: Interview question template
 - [ ] Create Appendix B: Detailed performance data tables
 - [ ] Create Appendix C: Test environment specifications
 - [ ] Create Appendix D: Nsight configuration details
 - [ ] Update appendices list in main.tex
+- [ ] Update list of figures, tables, table of contents
+- [ ] Check acronyms list (add any missing)
+- [ ] Verify all cross-references work
 
-**Goal**: Meaningful appendices created
+**Goal**: Appendices created, all lists correct
 **Target hours**: 8 hours
 
 ---
 
 ### Monday, February 02 (Day 18)
-- [ ] Update list of figures (ensure auto-generated correctly)
-- [ ] Update list of tables
-- [ ] Update table of contents
-- [ ] Check acronyms list (add any missing)
-- [ ] Verify all cross-references work
+**First Complete Review**
 
-**Goal**: All lists and cross-references correct
-**Target hours**: 4 hours
-
----
-
-### Tuesday, February 03 (Day 19)
-- [ ] Compile complete thesis (use Overleaf if local LaTeX issues)
+- [ ] Compile complete thesis
 - [ ] Read entire thesis start to finish
 - [ ] Make notes of sections needing improvement
 - [ ] Check logical flow between chapters
@@ -218,7 +252,9 @@
 
 ---
 
-### Wednesday, February 04 (Day 20)
+### Tuesday, February 03 (Day 19)
+**Fix Issues & Polish**
+
 - [ ] Fix top 15 issues from review list
 - [ ] Improve transitions between chapters
 - [ ] Ensure terminology consistency
@@ -230,14 +266,30 @@
 
 ---
 
-### Thursday, February 05 (Day 21)
+### Wednesday, February 04 (Day 20)
+**Final Polish & Send to Advisor**
+
 - [ ] Fix remaining issues from review list
 - [ ] Final polish pass on all chapters
 - [ ] Recompile thesis
 - [ ] Read abstract and conclusions again
-- [ ] Prepare to send to advisor
+- [ ] Send thesis PDF to advisor (dr inż. Michał Chwesiuk)
 
-**✅ WEEK 3 MILESTONE**: Complete, readable thesis ready for feedback
+**✅ DELAYED WEEK 3 MILESTONE**: Complete thesis sent for feedback
+**Target hours**: 4 hours
+
+---
+
+### Thursday, February 05 (Day 21)
+**Proofreading Pass 1**
+
+- [ ] Proofread abstract (Polish + English)
+- [ ] Check Polish grammar and style
+- [ ] Proofread Chapters 1-3
+- [ ] Check for typos and grammar errors
+- [ ] Verify technical terminology is correct
+
+**Goal**: First half proofread
 **Target hours**: 4 hours
 
 ---
@@ -245,43 +297,23 @@
 ## 📅 Week 4: February 6-15 - FINAL POLISH & SUBMISSION
 
 ### Friday, February 06 (Day 22)
-- [ ] Send thesis PDF to advisor (dr inż. Michał Chwesiuk)
-- [ ] Proofread abstract again (Polish)
-- [ ] Proofread abstract again (English)
-- [ ] Check Polish grammar and style
-- [ ] Verify formatting against WUT requirements
+**Proofreading Pass 2 + Advisor Feedback**
 
-**Goal**: Thesis sent for review, self-review done
+- [ ] Incorporate advisor feedback (if received)
+- [ ] Proofread Chapters 4-6
+- [ ] Check all code listings format correctly
+- [ ] Verify all URLs in bibliography work
+- [ ] Check footnotes
+
+**Goal**: More proofreading, feedback addressed
 **Target hours**: 8 hours
 
 ---
 
 ### Saturday, February 07 (Day 23)
-- [ ] Continue proofreading (Chapters 1-3)
-- [ ] Check for typos and grammar errors
-- [ ] Verify technical terminology is correct
-- [ ] Check equation formatting (if any)
-- [ ] Wait for advisor feedback
+**Final Proofreading + Formatting Check**
 
-**Goal**: Thorough proofreading of early chapters
-**Target hours**: 8 hours
-
----
-
-### Sunday, February 08 (Day 24)
-- [ ] Incorporate advisor feedback (if received)
-- [ ] Continue proofreading (Chapters 4-6)
-- [ ] Check all code listings format correctly
-- [ ] Verify all URLs in bibliography work
-- [ ] Check footnotes
-
-**Goal**: Advisor feedback addressed, more proofreading
-**Target hours**: 8 hours
-
----
-
-### Monday, February 09 (Day 25)
-- [ ] Final proofreading (Chapters 7-8)
+- [ ] Proofread Chapters 7-8
 - [ ] Check formatting requirements:
   - [ ] Margins correct
   - [ ] Font sizes correct
@@ -289,45 +321,79 @@
   - [ ] Page numbers correct
   - [ ] Headers/footers correct
 - [ ] Verify title page information
+- [ ] Verify formatting against WUT requirements
 
 **Goal**: Complete proofreading, formatting verified
-**Target hours**: 4 hours
+**Target hours**: 8 hours
 
 ---
 
-### Tuesday, February 10 (Day 26)
+### Sunday, February 08 (Day 24)
+**Final Compilation & Verification**
+
 - [ ] Compile final PDF
 - [ ] Verify all citations compile without errors
 - [ ] Check all figures render correctly
 - [ ] Verify all cross-references point to correct pages
 - [ ] Run spell-check on Polish sections
 - [ ] Run spell-check on English sections
+- [ ] Create backup of everything (thesis, source, data)
 
 **Goal**: Final, clean PDF generated
-**Target hours**: 4 hours
+**Target hours**: 8 hours
 
 ---
 
-### Wednesday, February 11 (Day 27)
+### Monday, February 09 (Day 25)
+**Submission Preparation**
+
 - [ ] Check WUT submission requirements (digital/print)
 - [ ] Print required number of copies (if needed)
 - [ ] Bind thesis at print shop (if needed)
 - [ ] Prepare digital submission files
-- [ ] Create backup of everything (thesis, source, data)
+- [ ] Prepare any additional documents needed
 
 **Goal**: Physical copies ready (if required)
 **Target hours**: 4 hours
 
 ---
 
-### Thursday, February 12 (Day 28)
-- [ ] Final review of submission requirements
-- [ ] Prepare any additional documents needed
-- [ ] Triple-check deadline and submission process
-- [ ] Rest and prepare mentally
-- [ ] Have submission checklist ready for tomorrow
+### Tuesday, February 10 (Day 26)
+**Buffer Day - Final Fixes**
 
-**Goal**: Ready for submission, peace of mind
+- [ ] Address any last-minute issues
+- [ ] Final review of submission requirements
+- [ ] Triple-check deadline and submission process
+- [ ] Test upload process if possible
+- [ ] Rest and prepare mentally
+
+**Goal**: Everything ready, peace of mind
+**Target hours**: 4 hours
+
+---
+
+### Wednesday, February 11 (Day 27)
+**Buffer Day**
+
+- [ ] Handle any unexpected issues
+- [ ] Final verification of all materials
+- [ ] Ensure submission files are ready
+- [ ] Have submission checklist ready
+
+**Goal**: Buffer for emergencies
+**Target hours**: 4 hours
+
+---
+
+### Thursday, February 12 (Day 28)
+**Buffer Day**
+
+- [ ] Final review of everything
+- [ ] Address any last issues
+- [ ] Prepare thesis files for upload
+- [ ] Rest before submission
+
+**Goal**: Ready for submission
 **Target hours**: 4 hours
 
 ---

data/nsight/unity_full_95s_osrt_sum_osrt_sum.csv

@@ -0,0 +1,64 @@
+Time (%),Total Time (ns),Num Calls,Avg (ns),Med (ns),Min (ns),Max (ns),StdDev (ns),Name
+95.9,109685225789,247,444069740.0,88486.0,1002,11047839463,1475404684.1,futex
+2.7,3052269233,85,35909049.8,7070645.0,7054145,2000066753,216470459.7,pthread_cond_timedwait
+0.6,743255450,26,28586748.1,10433055.5,12603,473975447,91202035.0,pthread_cond_wait
+0.3,314329234,349,900656.8,10199.0,1002,21271840,3568790.0,poll
+0.2,284182972,1907,149021.0,19376.0,1022,29882013,724581.9,ioctl
+0.2,231496282,23,10065055.7,10063640.0,10057198,10079139,6219.9,usleep
+0.0,23803638,22155,1074.4,1042.0,1001,24707,287.1,openat64
+0.0,10062257,1,10062257.0,10062257.0,10062257,10062257,0.0,nanosleep
+0.0,3178651,81,39242.6,33343.0,26369,91832,13625.2,pthread_create
+0.0,2886714,235,12283.9,2574.0,1001,741025,50962.3,read
+0.0,2786027,18,154779.3,15293.5,1052,1709656,422848.8,ppoll
+0.0,2569524,149,17245.1,6472.0,1623,226594,37551.2,mmap64
+0.0,1432407,553,2590.2,1843.0,1002,60172,3967.6,open64
+0.0,1015166,166,6115.5,1447.0,1001,319508,26108.8,close
+0.0,876780,548,1600.0,1493.0,1022,9447,614.7,fopen
+0.0,823467,340,2422.0,1383.0,1002,64320,5633.1,recvmsg
+0.0,763586,472,1617.8,1412.5,1092,19797,1159.1,open
+0.0,685529,130,5273.3,3597.0,1743,69640,7603.5,munmap
+0.0,503944,204,2470.3,2354.0,1522,13405,1248.3,fopen64
+0.0,495545,261,1898.6,1553.0,1082,8345,867.6,writev
+0.0,491677,317,1551.0,1332.0,1042,8235,743.9,fread
+0.0,470493,137,3434.3,2525.0,1653,18645,2271.8,mmap
+0.0,468014,4,117003.5,64635.5,58860,279883,108699.5,sem_wait
+0.0,445684,214,2082.6,1262.0,1012,54401,4116.9,recv
+0.0,354893,20,17744.7,17197.0,9568,33403,5382.3,sem_timedwait
+0.0,353741,12,29478.4,4092.5,1072,292657,83008.2,pthread_mutex_lock
+0.0,321881,3,107293.7,106589.0,75120,140172,32531.7,pthread_join
+0.0,291867,130,2245.1,1503.0,1052,12603,1848.2,fclose
+0.0,276167,89,3103.0,2425.0,1313,11862,1829.7,mprotect
+0.0,217148,89,2439.9,1893.0,1042,7484,1446.0,send
+0.0,213216,42,5076.6,4653.5,1042,24435,4508.3,fstat64
+0.0,168343,52,3237.4,1493.0,1002,13425,2966.9,stat64
+0.0,166923,32,5216.3,3506.0,1002,14698,4171.2,fflush
+0.0,158553,49,3235.8,1893.0,1002,22532,3786.6,getc
+0.0,110887,22,5040.3,4167.5,2134,11622,2487.3,pthread_kill
+0.0,87251,17,5132.4,3777.0,2154,12824,2933.7,socket
+0.0,80880,44,1838.2,1538.0,1012,3968,718.8,write
+0.0,74547,14,5324.8,5805.5,1733,10520,2627.7,connect
+0.0,71494,14,5106.7,5285.0,1152,7174,1500.6,pthread_mutex_trylock
+0.0,67676,25,2707.0,2444.0,1002,7404,1759.4,fgets
+0.0,67608,25,2704.3,2815.0,1022,5401,1120.4,sendmsg
+0.0,49624,22,2255.6,1864.0,1312,8045,1493.3,pthread_cond_broadcast
+0.0,40325,9,4480.6,3977.0,2875,6222,1216.7,socketpair
+0.0,23865,7,3409.3,3377.0,1212,5861,1991.9,statx
+0.0,22030,4,5507.5,5299.5,4058,7373,1462.4,pipe2
+0.0,18084,4,4521.0,4764.0,3587,4969,637.1,memfd_create
+0.0,13406,10,1340.6,1332.5,1002,1834,294.3,fcntl64
+0.0,7775,3,2591.7,2946.0,1513,3316,952.3,lockf
+0.0,6712,1,6712.0,6712.0,6712,6712,0.0,fstat
+0.0,6262,1,6262.0,6262.0,6262,6262,0.0,bind
+0.0,5109,1,5109.0,5109.0,5109,5109,0.0,fgetc
+0.0,5030,1,5030.0,5030.0,5030,5030,0.0,posix_fallocate
+0.0,4749,2,2374.5,2374.5,1953,2796,596.1,ftruncate
+0.0,4428,1,4428.0,4428.0,4428,4428,0.0,signal
+0.0,3977,2,1988.5,1988.5,1803,2174,262.3,prctl
+0.0,3728,3,1242.7,1333.0,1042,1353,174.1,stat
+0.0,3516,3,1172.0,1162.0,1002,1352,175.2,fcntl
+0.0,2685,1,2685.0,2685.0,2685,2685,0.0,dup2
+0.0,2284,1,2284.0,2284.0,2284,2284,0.0,flock
+0.0,2194,2,1097.0,1097.0,1012,1182,120.2,shutdown
+0.0,2184,2,1092.0,1092.0,1002,1182,127.3,pthread_barrier_wait
+0.0,1353,1,1353.0,1353.0,1353,1353,0.0,sigaction
+0.0,1182,1,1182.0,1182.0,1182,1182,0.0,pthread_cond_signal

data/nsight/unity_full_95s_vulkan_sum_vulkan_api_sum.csv

@@ -0,0 +1,32 @@
+Time (%),Total Time (ns),Num Calls,Avg (ns),Med (ns),Min (ns),Max (ns),StdDev (ns),Name
+95.2,77035025207,12895,5974022.9,6226298.0,71344,1181173209,10407753.0,vkWaitForFences
+3.2,2606801836,13556,192298.7,23724.0,10079,7203784,1050221.3,vkQueuePresentKHR
+0.8,684409222,27112,25243.8,13260.0,2424,2694446,27619.4,vkQueueSubmit
+0.2,162349177,1,162349177.0,162349177.0,162349177,162349177,0.0,vkCreateDevice
+0.2,135602212,341,397660.4,242924.0,221454,24310219,1397552.4,vkCreateFence
+0.1,103055413,40679,2533.4,1763.0,431,2049100,17161.0,vkBeginCommandBuffer
+0.1,77015589,1,77015589.0,77015589.0,77015589,77015589,0.0,vkCreateSwapchainKHR
+0.0,29754572,40679,731.4,632.0,140,115917,1170.5,vkEndCommandBuffer
+0.0,29045294,27027,1074.7,992.0,351,36418,921.3,vkCmdBindPipeline
+0.0,18761537,40800,459.8,391.0,110,97201,990.4,vkCmdPipelineBarrier
+0.0,16356988,13556,1206.6,1062.0,431,110967,2095.1,vkAcquireNextImageKHR
+0.0,15065229,22,684783.1,648491.5,53490,1870827,451826.1,vkAllocateMemory
+0.0,8777401,687,12776.4,12083.0,3536,66945,3687.2,vkAllocateCommandBuffers
+0.0,5070296,8,633787.0,682761.0,119393,838968,215524.1,vkFreeMemory
+0.0,1140167,239,4770.6,1222.0,1001,195726,13879.5,vkCmdBindDescriptorSets
+0.0,840766,687,1223.8,221.0,90,10059,1561.3,vkCreateCommandPool
+0.0,764088,3,254696.0,14507.0,3607,745974,425494.1,vkAllocateDescriptorSets
+0.0,380461,3,126820.3,117680.0,110266,152515,22558.9,vkCreateGraphicsPipelines
+0.0,273311,1,273311.0,273311.0,273311,273311,0.0,vkQueueWaitIdle
+0.0,235621,106,2222.8,2134.0,170,11221,2049.7,vkCreateImage
+0.0,168232,111,1515.6,741.0,340,9107,1594.3,vkCreateImageView
+0.0,107699,34,3167.6,2870.5,1082,6623,982.9,vkCreateSemaphore
+0.0,86890,106,819.7,581.0,361,4268,707.9,vkBindImageMemory
+0.0,45377,50,907.5,817.0,341,2124,476.4,vkBindBufferMemory
+0.0,36440,6,6073.3,4278.5,1814,18985,6477.4,vkCreateShaderModule
+0.0,30529,50,610.6,426.0,120,1983,451.6,vkCreateBuffer
+0.0,26790,8,3348.8,1247.0,431,14427,4888.3,vkCreateRenderPass2KHR
+0.0,17601,22,800.0,606.5,90,5380,1062.3,vkUpdateDescriptorSetWithTemplateKHR
+0.0,3527,17,207.5,191.0,30,641,164.5,vkMapMemory
+0.0,2295,7,327.9,351.0,220,481,91.2,vkUnmapMemory
+0.0,381,1,381.0,381.0,381,381,0.0,vkCreateFramebuffer

latex/main.app

@@ -1,2 +1,2 @@
-\contentsline {subsection}{\hspace *{-1.1em}1.\hspace *{0.5em} Nazwa załącznika 1}{52}{section*.16}%
-\contentsline {subsection}{\hspace *{-1.1em}2.\hspace *{0.5em} Nazwa załącznika 2}{54}{section*.18}%
+\contentsline {subsection}{\hspace *{-1.1em}1.\hspace *{0.5em} Nazwa załącznika 1}{44}{section*.18}%
+\contentsline {subsection}{\hspace *{-1.1em}2.\hspace *{0.5em} Nazwa załącznika 2}{46}{section*.20}%

latex/tex/4-metodologia.tex

@@ -41,15 +41,115 @@ Głównym celem badań jest obiektywne porównanie wydajności i możliwości wy
 \end{itemize}
 
 \subsection{Środowisko testowe}
+
 \subsubsection{Specyfikacja sprzętowa}
-% Szczegółowy opis konfiguracji sprzętowej używanej do testów
+\label{subsubsec:specyfikacja-sprzetowa}
+
+Wszystkie testy wydajnościowe przeprowadzono na komputerze o następującej specyfikacji:
+
+\begin{itemize}
+    \item \textbf{Procesor}: AMD Ryzen 9 7900X3D 12-Core Processor (24 rdzenie, 48 wątków)
+    \item \textbf{Karta graficzna}: NVIDIA GeForce RTX 3090
+    \item \textbf{Pamięć GPU}: 24 GB GDDR6X
+    \item \textbf{Sterowniki NVIDIA}: wersja 590.48.01
+    \item \textbf{Pamięć RAM}: 32 GB
+    \item \textbf{System operacyjny}: Arch Linux (jądro Linux 6.18.5-arch1-1)
+    \item \textbf{Dysk}: SSD o pojemności 3,6 TB
+\end{itemize}
 
 \subsubsection{Specyfikacja oprogramowania}
-% Wersje systemów operacyjnych, sterowników, silników
+\label{subsubsec:specyfikacja-oprogramowania}
+
+W badaniach wykorzystano następujące wersje oprogramowania:
+
+\begin{itemize}
+    \item \textbf{Unity}: 6.0 (6000.0.58f2) LTS
+    \item \textbf{Unreal Engine}: 5.5.3
+    \item \textbf{NVIDIA Nsight Systems}: 2025.5.2
+\end{itemize}
+
+Wybór wersji LTS silnika Unity podyktowany był stabilnością oraz długoterminowym wsparciem, co jest istotne z punktu widzenia powtarzalności badań. W przypadku Unreal Engine wybrano najnowszą dostępną wersję stabilną w momencie rozpoczęcia badań.
+
+\subsubsection{Konfiguracja testowa}
+\label{subsubsec:konfiguracja-testowa}
+
+Przed wykonaniem każdego testu zastosowano następującą procedurę przygotowawczą:
+\begin{enumerate}
+    \item Zamknięto wszystkie aplikacje działające w tle
+    \item Wyłączono automatyczne aktualizacje systemu
+    \item Ustawiono tryb wydajności zasilania (performance mode)
+    \item Odczekano 5 minut na stabilizację termiczną systemu
+    \item Wykonano 3 pomiary dla każdego scenariusza testowego, z których obliczono wartość średnią
+\end{enumerate}
 
 \subsection{Projekt testów}
-\subsubsection{Scenariusze testowe}
-% Opis konkretnych scenariuszy używanych do porównania
+
+\subsubsection{Gra testowa typu \emph{bullet hell}}
+\label{subsubsec:gra-testowa}
+
+Na potrzeby badań porównawczych zaimplementowano identyczną grę w gatunku \emph{bullet hell} w obu silnikach. Gra charakteryzuje się następującymi cechami:
+
+\begin{itemize}
+    \item Sterowany przez gracza statek kosmiczny
+    \item System generowania przeciwników z progresywnie rosnącym obciążeniem
+    \item Generowanie wzorców pocisków
+    \item Wykrywanie kolizji między obiektami
+    \item Tryb przetrwania trwający 90 sekund
+\end{itemize}
+
+Wybór gatunku \emph{bullet hell} podyktowany był możliwością generowania dużej liczby obiektów na ekranie (pociski, przeciwnicy, efekty wizualne), co pozwala na skuteczne obciążenie silnika graficznego i zbadanie jego wydajności w warunkach ekstremalnych.
+
+\subsubsection{Fazy obciążenia}
+\label{subsubsec:fazy-obciazenia}
+
+Gra testowa została zaprojektowana tak, aby w ciągu 90 sekund rozgrywki przechodziła przez trzy fazy o różnym poziomie obciążenia:
+
+\paragraph{Faza 1: Niskie obciążenie (0--30 sekund)}
+\begin{itemize}
+    \item Liczba pocisków na ekranie: 50--100
+    \item Aktywni przeciwnicy: 2--3
+    \item Oczekiwana stabilna liczba klatek: 60 FPS
+    \item Oczekiwane wykorzystanie GPU: poniżej 50\%
+\end{itemize}
+
+\paragraph{Faza 2: Średnie obciążenie (30--60 sekund)}
+\begin{itemize}
+    \item Liczba pocisków na ekranie: 200--300
+    \item Aktywni przeciwnicy: 5--7
+    \item Oczekiwane wykorzystanie GPU: 50--70\%
+    \item Możliwe niewielkie spadki liczby klatek
+\end{itemize}
+
+\paragraph{Faza 3: Wysokie obciążenie (60--90 sekund)}
+\begin{itemize}
+    \item Liczba pocisków na ekranie: ponad 500
+    \item Aktywni przeciwnicy: ponad 10
+    \item Oczekiwane wykorzystanie GPU: powyżej 70\%
+    \item Potencjalne znaczące spadki liczby klatek
+\end{itemize}
 
 \subsubsection{Metryki i wskaźniki}
-% Definicja mierzonych parametrów i sposobów ich pomiaru
+\label{subsubsec:metryki}
+
+W ramach testów wydajnościowych mierzono następujące parametry:
+
+\begin{enumerate}
+    \item \textbf{Czas klatki} (ang. \emph{frame time}) -- czas potrzebny na wyrenderowanie pojedynczej klatki, wyrażony w milisekundach
+    \item \textbf{Liczba klatek na sekundę} (FPS) -- wartość pochodna od czasu klatki
+    \item \textbf{Wykorzystanie GPU} -- procentowe obciążenie karty graficznej
+    \item \textbf{Zużycie pamięci} -- pamięć VRAM oraz RAM wykorzystywana przez aplikację
+    \item \textbf{Liczba wywołań rysowania} (ang. \emph{draw calls}) -- liczba wywołań API graficznego na klatkę
+    \item \textbf{Liczba wierzchołków} -- całkowita liczba wierzchołków renderowanych na klatkę
+\end{enumerate}
+
+\subsubsection{Procedura zbierania danych}
+\label{subsubsec:procedura-zbierania}
+
+Dla każdego silnika przeprowadzono trzy pełne przebiegi gry (90 sekund każdy), co dało łącznie 6 sesji pomiarowych. Narzędzie NVIDIA Nsight Systems rejestrowało dane wydajnościowe przez cały czas trwania rozgrywki, umożliwiając późniejszą analizę poszczególnych faz obciążenia.
+
+Punkty pomiaru dla każdej fazy:
+\begin{itemize}
+    \item \textbf{Faza 1}: 10s (wczesne niskie obciążenie), 20s (stabilne niskie obciążenie), 25s (koniec fazy)
+    \item \textbf{Faza 2}: 35s (przejście do średniego obciążenia), 45s (stabilne średnie obciążenie), 55s (koniec fazy)
+    \item \textbf{Faza 3}: 65s (przejście do wysokiego obciążenia), 75s (szczytowe obciążenie), 85s (koniec fazy)
+\end{itemize}

latex/tex/5-testy-wydajnosci.tex

@@ -3,55 +3,91 @@
 \label{sec:testy-wydajnosci}
 
 \subsection{Metodyka przeprowadzania testów}
+
 \subsubsection{Przygotowanie środowiska testowego}
-% Opis procesu przygotowania spójnego środowiska dla wszystkich silników
+
+Przed każdą sesją pomiarową wykonano następujące czynności przygotowawcze:
+\begin{enumerate}
+    \item Zamknięto wszystkie zbędne aplikacje działające w tle
+    \item Zweryfikowano, że system jest w stanie bezczynności
+    \item Uruchomiono NVIDIA Nsight Systems w trybie profilowania
+    \item Skonfigurowano Nsight do przechwytywania danych z uruchamianej gry
+\end{enumerate}
 
 \subsubsection{Standaryzacja warunków testowych}
-% Zapewnienie porównywalności wyników między różnymi silnikami
 
-\subsection{Test renderowania 2D}
-\subsubsection{Założenia testu}
-% Opis scenariusza testowego dla grafiki 2D
+W celu zapewnienia porównywalności wyników między silnikami Unity i Unreal Engine:
+\begin{itemize}
+    \item Obie gry uruchamiano w tej samej rozdzielczości (1920×1080)
+    \item Wyłączono synchronizację pionową (V-Sync) w obu implementacjach
+    \item Zastosowano identyczną mechanikę rozgrywki i parametry generowania przeciwników
+    \item Każdy test powtórzono trzykrotnie, obliczając wartości średnie
+\end{itemize}
 
-\subsubsection{Wyniki pomiarów}
-% Tabele i wykresy przedstawiające wyniki dla każdego silnika
+\subsection{Wyniki testów dla silnika Unity}
+\label{subsec:wyniki-unity}
 
-\subsubsection{Analiza wyników}
-% Interpretacja uzyskanych danych
+\subsubsection{Faza niskiego obciążenia (0--30 sekund)}
+% TODO: Wstawić dane z testów Unity - faza 1
+% Tabela z czasem klatki, FPS, GPU%, pamięć
 
-\subsection{Test renderowania 3D}
-\subsubsection{Scenariusz podstawowy}
-% Test renderowania prostej sceny 3D
+\subsubsection{Faza średniego obciążenia (30--60 sekund)}
+% TODO: Wstawić dane z testów Unity - faza 2
 
-\subsubsection{Scenariusz zaawansowany}
-% Test złożonych scen z wieloma obiektami, oświetleniem, cieniami
+\subsubsection{Faza wysokiego obciążenia (60--90 sekund)}
+% TODO: Wstawić dane z testów Unity - faza 3
 
-\subsubsection{Porównanie wyników}
-% Analiza porównawcza wydajności renderowania 3D
+\subsection{Wyniki testów dla silnika Unreal Engine}
+\label{subsec:wyniki-unreal}
 
-\subsection{Test systemów fizyki}
-\subsubsection{Symulacja kolizji}
-% Testy wydajności przy różnej liczbie obiektów fizycznych
+\subsubsection{Faza niskiego obciążenia (0--30 sekund)}
+% TODO: Wstawić dane z testów Unreal - faza 1
 
-\subsubsection{Symulacja płynów i cząstek}
-% Testy zaawansowanych systemów fizyki
+\subsubsection{Faza średniego obciążenia (30--60 sekund)}
+% TODO: Wstawić dane z testów Unreal - faza 2
 
-\subsection{Test zużycia zasobów systemowych}
-\subsubsection{Zużycie pamięci RAM}
-% Pomiary zużycia pamięci operacyjnej
+\subsubsection{Faza wysokiego obciążenia (60--90 sekund)}
+% TODO: Wstawić dane z testów Unreal - faza 3
 
-\subsubsection{Obciążenie procesora}
-% Analiza wykorzystania CPU
+\subsection{Analiza porównawcza}
+\label{subsec:analiza-porownawcza}
 
-\subsubsection{Zużycie pamięci GPU}
-% Pomiary zużycia pamięci karty graficznej
+\subsubsection{Porównanie czasu klatki}
+% TODO: Wykres porównawczy frame time Unity vs Unreal
+% \begin{figure}[htbp]
+%     \centering
+%     \includegraphics[width=0.9\textwidth]{img/frame-time-comparison.png}
+%     \caption{Porównanie czasu klatki między Unity a Unreal Engine}
+%     \label{fig:frame-time-comparison}
+% \end{figure}
 
-\subsection{Test wydajności na różnych platformach}
-\subsubsection{Testy na PC (Windows/Linux)}
-% Porównanie wydajności na systemach desktop
+\subsubsection{Porównanie wykorzystania GPU}
+% TODO: Wykres porównawczy GPU utilization
 
-\subsubsection{Testy na urządzeniach mobilnych}
-% Analiza wydajności na platformach mobilnych (jeśli dotyczy)
+\subsubsection{Porównanie zużycia pamięci}
+% TODO: Wykres porównawczy memory usage
+
+\subsubsection{Porównanie liczby wywołań rysowania}
+% TODO: Analiza draw calls
 
 \subsection{Podsumowanie wyników testów wydajności}
-% Zestawienie wszystkich uzyskanych wyników w formie tabelarycznej i graficznej
+\label{subsec:podsumowanie-testow}
+
+% TODO: Tabela zbiorcza ze wszystkimi metrykami
+% \begin{table}[htbp]
+%     \centering
+%     \caption{Zestawienie wyników testów wydajności}
+%     \label{tab:wyniki-wydajnosci}
+%     \begin{tabular}{lcccccc}
+%         \toprule
+%         \textbf{Metryka} & \multicolumn{3}{c}{\textbf{Unity}} & \multicolumn{3}{c}{\textbf{Unreal Engine}} \\
+%         & Niska & Średnia & Wysoka & Niska & Średnia & Wysoka \\
+%         \midrule
+%         Czas klatki (ms) & -- & -- & -- & -- & -- & -- \\
+%         FPS & -- & -- & -- & -- & -- & -- \\
+%         GPU (\%) & -- & -- & -- & -- & -- & -- \\
+%         Pamięć (MB) & -- & -- & -- & -- & -- & -- \\
+%         Draw calls & -- & -- & -- & -- & -- & -- \\
+%         \bottomrule
+%     \end{tabular}
+% \end{table}

magisterka_2/Assets/Scripts/PlayerController.cs

@@ -34,6 +34,8 @@ namespace Magisterka.BulletHell
         [SerializeField] private KeyCode fireKey = KeyCode.Z;
         [SerializeField] private KeyCode modifierKey = KeyCode.LeftShift;
         [SerializeField] private KeyCode bombKey = KeyCode.X;
+        [SerializeField] private KeyCode invincibilityToggleKey = KeyCode.I;
+        [SerializeField] private KeyCode inactiveModeToggleKey = KeyCode.P;
 
     private const int MaxLevel = 12;
 
@@ -55,6 +57,10 @@ namespace Magisterka.BulletHell
     private float _baseBulletSpeed;
     private int _baseVolleyWidth;
     
+    // Testing modes
+    private bool _permanentInvincibility;
+    private bool _inactiveMode;
+
         public void Initialize(BulletPool bulletPool, Vector2 movementBounds)
         {
             Instance = this;
@@ -81,6 +87,9 @@ namespace Magisterka.BulletHell
             _fireCooldown = 0f;
             _victoryAchieved = false;
 
+            // Check command-line arguments for test modes
+            CheckCommandLineArgs();
+
             if (ScoreManager.Instance != null)
             {
                 ScoreManager.Instance.ScoreChanged += HandleScoreChanged;
@@ -88,6 +97,33 @@ namespace Magisterka.BulletHell
             }
         }
 
+        /// <summary>
+        /// Check command-line arguments for automated test modes.
+        /// Usage: ./Final.x86_64 --invincible --stationary
+        /// </summary>
+        private void CheckCommandLineArgs()
+        {
+            string[] args = System.Environment.GetCommandLineArgs();
+            foreach (string arg in args)
+            {
+                if (arg == "--invincible" || arg == "-i")
+                {
+                    _permanentInvincibility = true;
+                    _isInvulnerable = true;
+                    Debug.Log("[TEST] Command-line: Invincibility ENABLED");
+                    if (_renderer != null)
+                    {
+                        _renderer.color = Color.yellow;
+                    }
+                }
+                else if (arg == "--stationary" || arg == "-s")
+                {
+                    _inactiveMode = true;
+                    Debug.Log("[TEST] Command-line: Stationary mode ENABLED");
+                }
+            }
+        }
+
         public static PlayerController CreatePlayer(Transform parent, BulletPool playerBulletPool, Vector2 movementBounds)
         {
             var playerGO = new GameObject("Player");
@@ -119,6 +155,36 @@ namespace Magisterka.BulletHell
                 return;
             }
 
+            // Toggle invincibility with I key
+            if (Input.GetKeyDown(invincibilityToggleKey))
+            {
+                _permanentInvincibility = !_permanentInvincibility;
+                Debug.Log($"[TEST] Invincibility: {(_permanentInvincibility ? "ON" : "OFF")}");
+                if (_permanentInvincibility)
+                {
+                    _isInvulnerable = true;
+                    if (_renderer != null)
+                    {
+                        _renderer.color = Color.yellow;
+                    }
+                }
+                else
+                {
+                    _isInvulnerable = false;
+                    if (_renderer != null)
+                    {
+                        _renderer.color = _baseColor;
+                    }
+                }
+            }
+
+            // Toggle inactive mode with P key
+            if (Input.GetKeyDown(inactiveModeToggleKey))
+            {
+                _inactiveMode = !_inactiveMode;
+                Debug.Log($"[TEST] Inactive Mode: {(_inactiveMode ? "ON (stationary)" : "OFF (active)")}");
+            }
+
             if (_fireCooldown > 0f)
             {
                 _fireCooldown -= Time.deltaTime;
@@ -129,8 +195,12 @@ namespace Magisterka.BulletHell
                 return;
             }
 
+            // Skip movement and shooting in inactive mode
+            if (!_inactiveMode)
+            {
                 HandleMovement();
                 HandleShooting();
+            }
             HandleBomb();
         }
 
@@ -250,8 +320,12 @@ namespace Magisterka.BulletHell
                 yield return null;
             }
 
+            // Only disable invulnerability if permanent mode is off
+            if (!_permanentInvincibility)
+            {
                 _isInvulnerable = false;
                 _renderer.color = _baseColor;
+            }
             _canControl = true;
         }
 
@@ -318,8 +392,16 @@ namespace Magisterka.BulletHell
                 _renderer.color = _baseColor;
             }
 
+            // Only disable invulnerability if permanent mode is off
+            if (!_permanentInvincibility)
+            {
                 _isInvulnerable = false;
                 _renderer.color = _baseColor;
+            }
+            else
+            {
+                _renderer.color = Color.yellow;
+            }
             _isAlive = true;
             _canControl = true;
         }

magisterka_2/Final_Data/boot.config

@@ -2,4 +2,4 @@ gfx-threading-mode=4
 wait-for-native-debugger=0
 hdr-display-enabled=0
 gc-max-time-slice=3
-build-guid=009181753e304fef90d5ca0f6449663a
+build-guid=fec09034c859405798fa881839c4d0e2

scripts/close_background_apps.sh

@@ -0,0 +1,65 @@
+#!/bin/bash
+# close_background_apps.sh
+# Script to close unnecessary background applications before performance testing
+# Author: Krzysztof Rudnicki
+# Date: January 19, 2026
+
+echo "=== Closing Background Applications for Performance Testing ==="
+echo ""
+
+# List of common background applications to close
+# Add or remove applications as needed for your system
+APPS_TO_CLOSE=(
+    "firefox"
+    "chromium"
+    "chrome"
+    "brave"
+    # "code"         # VS Code - KEEP RUNNING (needed for development)
+    "slack"
+    "discord"
+    "spotify"
+    "telegram"
+    "teams"
+    "zoom"
+    "dropbox"
+    "syncthing"
+    "steam"
+    "lutris"
+)
+
+# Function to gracefully close an application
+close_app() {
+    local app_name="$1"
+    if pgrep -x "$app_name" > /dev/null 2>&1; then
+        echo "Closing $app_name..."
+        pkill -TERM "$app_name" 2>/dev/null
+        sleep 1
+        # Force kill if still running
+        if pgrep -x "$app_name" > /dev/null 2>&1; then
+            pkill -KILL "$app_name" 2>/dev/null
+        fi
+    fi
+}
+
+# Close each application in the list
+for app in "${APPS_TO_CLOSE[@]}"; do
+    close_app "$app"
+done
+
+echo ""
+echo "=== Background applications closed ==="
+echo ""
+
+# Show remaining resource-intensive processes
+echo "Top 10 CPU-consuming processes:"
+echo "--------------------------------"
+ps aux --sort=-%cpu | head -11 | tail -10
+
+echo ""
+echo "Top 10 Memory-consuming processes:"
+echo "----------------------------------"
+ps aux --sort=-%mem | head -11 | tail -10
+
+echo ""
+echo "=== System ready for performance testing ==="
+echo "Note: Verify no unwanted processes are still running before starting tests."

scripts/hardware_specs.tex

@@ -0,0 +1,42 @@
+% Hardware Specifications for Thesis
+% Generated automatically - use in Chapter 4 Methodology
+
+\subsubsection{Specyfikacja sprzętowa}
+\label{subsubsec:specyfikacja-sprzetowa}
+
+Wszystkie testy wydajnościowe przeprowadzono na komputerze o następującej specyfikacji:
+
+\begin{itemize}
+    \item \textbf{Procesor}: AMD Ryzen 9 7900X3D 12-Core Processor (24 rdzenie, 48 wątków)
+    \item \textbf{Karta graficzna}: NVIDIA GeForce RTX 3090
+    \item \textbf{Pamięć GPU}: 24 GB GDDR6X
+    \item \textbf{Sterowniki NVIDIA}: wersja 590.48.01
+    \item \textbf{Pamięć RAM}: 32 GB
+    \item \textbf{System operacyjny}: Arch Linux (jądro Linux 6.18.5-arch1-1)
+    \item \textbf{Dysk}: SSD o pojemności 3,6 TB
+\end{itemize}
+
+\subsubsection{Specyfikacja oprogramowania}
+\label{subsubsec:specyfikacja-oprogramowania}
+
+W badaniach wykorzystano następujące wersje oprogramowania:
+
+\begin{itemize}
+    \item \textbf{Unity}: 6.0 (6000.0.58f2) LTS
+    \item \textbf{Unreal Engine}: 5.5.3
+    \item \textbf{NVIDIA Nsight Systems}: 2025.5.2
+\end{itemize}
+
+Wybór wersji LTS silnika Unity podyktowany był stabilnością oraz długoterminowym wsparciem, co jest istotne z punktu widzenia powtarzalności badań. W przypadku Unreal Engine wybrano najnowszą dostępną wersję stabilną w momencie rozpoczęcia badań.
+
+\subsubsection{Konfiguracja testowa}
+\label{subsubsec:konfiguracja-testowa}
+
+Przed wykonaniem każdego testu zastosowano następującą procedurę przygotowawczą:
+\begin{enumerate}
+    \item Zamknięto wszystkie aplikacje działające w tle
+    \item Wyłączono automatyczne aktualizacje systemu
+    \item Ustawiono tryb wydajności zasilania (performance mode)
+    \item Odczekano 5 minut na stabilizację termiczną systemu
+    \item Wykonano 3 pomiary dla każdego scenariusza testowego, z których obliczono wartość średnią
+\end{enumerate}

scripts/profile_unity.sh

@@ -0,0 +1,122 @@
+#!/bin/bash
+# =============================================================================
+# Unity Nsight Profiling Script
+# =============================================================================
+# Profiles the Unity bullet-hell game with NVIDIA Nsight Systems
+#
+# Usage:
+#   ./profile_unity.sh [duration_seconds] [output_name]
+#
+# Examples:
+#   ./profile_unity.sh              # 95s profile, default name
+#   ./profile_unity.sh 60           # 60s profile
+#   ./profile_unity.sh 95 my_test   # 95s profile, custom name
+# =============================================================================
+
+set -e
+
+# Configuration
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_DIR="$(dirname "$SCRIPT_DIR")"
+DATA_DIR="$PROJECT_DIR/data/nsight"
+UNITY_GAME="$PROJECT_DIR/magisterka_2/Final.x86_64"
+
+# Arguments
+DURATION="${1:-95}"
+OUTPUT_NAME="${2:-unity_$(date +%Y%m%d_%H%M%S)}"
+OUTPUT_PATH="$DATA_DIR/$OUTPUT_NAME"
+
+# Colors
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+CYAN='\033[0;36m'
+BOLD='\033[1m'
+NC='\033[0m'
+
+echo -e "${CYAN}${BOLD}"
+echo "╔═══════════════════════════════════════════════════════════╗"
+echo "║           UNITY NSIGHT PROFILING                          ║"
+echo "╚═══════════════════════════════════════════════════════════╝"
+echo -e "${NC}"
+
+echo -e "${YELLOW}Configuration:${NC}"
+echo "  Duration:    ${DURATION}s"
+echo "  Output:      ${OUTPUT_PATH}.nsys-rep"
+echo "  Game:        ${UNITY_GAME}"
+echo ""
+
+# Create output directory
+mkdir -p "$DATA_DIR"
+
+# Step 1: Run profiler
+echo -e "${CYAN}[1/4] Running Nsight profiler (${DURATION}s)...${NC}"
+nsys profile \
+    --output="$OUTPUT_PATH" \
+    --trace=vulkan,osrt \
+    --duration="$DURATION" \
+    --force-overwrite=true \
+    -- "$UNITY_GAME" -force-vulkan --invincible --stationary
+
+echo -e "${GREEN}✓ Profiling complete${NC}"
+echo ""
+
+# Step 2: Export Vulkan API summary
+echo -e "${CYAN}[2/4] Exporting Vulkan API summary...${NC}"
+nsys stats -r vulkan_api_sum --format csv \
+    -o "${OUTPUT_PATH}_vulkan_api_sum" \
+    "${OUTPUT_PATH}.nsys-rep" 2>&1 | grep -E "PROCESSED|SKIPPED" || true
+echo -e "${GREEN}✓ Vulkan summary exported${NC}"
+
+# Step 3: Export OS runtime summary
+echo -e "${CYAN}[3/4] Exporting OS runtime summary...${NC}"
+nsys stats -r osrt_sum --format csv \
+    -o "${OUTPUT_PATH}_osrt_sum" \
+    "${OUTPUT_PATH}.nsys-rep" 2>&1 | grep -E "PROCESSED|SKIPPED" || true
+echo -e "${GREEN}✓ OS runtime summary exported${NC}"
+echo ""
+
+# Step 4: Calculate and display results
+echo -e "${CYAN}[4/4] Analyzing results...${NC}"
+echo ""
+
+# Get frame count from SQLite
+SQLITE_FILE="${OUTPUT_PATH}.sqlite"
+if [ -f "$SQLITE_FILE" ]; then
+    FRAMES=$(sqlite3 "$SQLITE_FILE" "SELECT COUNT(*) FROM VULKAN_API WHERE nameId IN (SELECT id FROM StringIds WHERE value='vkQueuePresentKHR');" 2>/dev/null || echo "0")
+    FPS=$(echo "scale=2; $FRAMES / $DURATION" | bc)
+else
+    FRAMES="N/A"
+    FPS="N/A"
+fi
+
+# Get report size
+REPORT_SIZE=$(ls -lh "${OUTPUT_PATH}.nsys-rep" | awk '{print $5}')
+
+# Display summary
+echo -e "${CYAN}${BOLD}═══════════════════════════════════════════════════════════${NC}"
+echo -e "${CYAN}${BOLD}                    PROFILING RESULTS                       ${NC}"
+echo -e "${CYAN}${BOLD}═══════════════════════════════════════════════════════════${NC}"
+echo ""
+echo -e "${YELLOW}Performance Metrics:${NC}"
+echo "  Duration:      ${DURATION} seconds"
+echo "  Total Frames:  ${FRAMES}"
+echo "  Average FPS:   ${FPS}"
+echo ""
+
+echo -e "${YELLOW}Generated Files:${NC}"
+echo "  Report:        ${OUTPUT_PATH}.nsys-rep (${REPORT_SIZE})"
+echo "  SQLite:        ${OUTPUT_PATH}.sqlite"
+ls "${OUTPUT_PATH}"*.csv 2>/dev/null | while read f; do
+    echo "  CSV:           $(basename "$f")"
+done
+echo ""
+
+# Display Vulkan API top 10
+echo -e "${YELLOW}Vulkan API Summary (Top 10 by time):${NC}"
+nsys stats -r vulkan_api_sum "${OUTPUT_PATH}.nsys-rep" 2>&1 | grep -A 15 "Time (%)" | head -13
+echo ""
+
+echo -e "${GREEN}${BOLD}Done!${NC}"
+echo ""
+echo "To view full report in Nsight UI:"
+echo "  nsys-ui ${OUTPUT_PATH}.nsys-rep"

scripts/run_unity_test.sh

@@ -1,146 +0,0 @@
-#!/bin/bash
-# Helper script to guide through Unity game testing with Nsight
-
-echo "======================================"
-echo "Unity Game + Nsight Testing Guide"
-echo "======================================"
-echo ""
-
-# Check if Nsight is installed
-if ! command -v nv-nsight-gfx &> /dev/null; then
-    echo "⚠️  NVIDIA Nsight Graphics not found in PATH"
-    echo ""
-    echo "To install:"
-    echo "1. Download from: https://developer.nvidia.com/nsight-graphics"
-    echo "2. Run the installer"
-    echo "3. Add to PATH or note installation directory"
-    echo ""
-    exit 1
-fi
-
-echo "✓ NVIDIA Nsight Graphics found"
-echo ""
-
-# Get scenario from user
-echo "Select test scenario:"
-echo "1) Low difficulty (50-100 bullets)"
-echo "2) Medium difficulty (200-300 bullets)"
-echo "3) High difficulty (500+ bullets)"
-read -p "Enter scenario number (1-3): " SCENARIO_NUM
-
-case $SCENARIO_NUM in
-    1)
-        SCENARIO="low"
-        SCENARIO_NAME="Low Difficulty"
-        ;;
-    2)
-        SCENARIO="medium"
-        SCENARIO_NAME="Medium Difficulty"
-        ;;
-    3)
-        SCENARIO="high"
-        SCENARIO_NAME="High Difficulty"
-        ;;
-    *)
-        echo "Invalid scenario number"
-        exit 1
-        ;;
-esac
-
-echo ""
-echo "Testing scenario: $SCENARIO_NAME"
-echo ""
-
-# Pre-test checklist
-echo "Pre-test checklist:"
-echo "- [ ] Close all background applications"
-echo "- [ ] Disable system updates"
-echo "- [ ] Set power mode to High Performance"
-echo "- [ ] Wait 5 minutes for system stabilization"
-echo ""
-read -p "Press Enter when ready to continue..."
-
-echo ""
-echo "Step 1: Launch Unity Game"
-echo "------------------------"
-echo "Navigate to the Unity bullet-hell game and launch it."
-echo "Select the '$SCENARIO_NAME' mode from the menu."
-echo ""
-read -p "Press Enter when Unity game is running..."
-
-echo ""
-echo "Step 2: Launch NVIDIA Nsight Graphics"
-echo "------------------------------------"
-echo "1. Open NVIDIA Nsight Graphics application"
-echo "2. Click 'Connect' or 'Attach to Process'"
-echo "3. Find the Unity process (usually 'Unity.exe' or similar)"
-echo "4. Click 'Attach'"
-echo ""
-read -p "Press Enter when Nsight is attached..."
-
-echo ""
-echo "Step 3: Start gameplay and capture frames"
-echo "----------------------------------------"
-echo "You will capture 5 frames at these time points:"
-echo "  - 5 seconds into gameplay"
-echo "  - 10 seconds into gameplay"
-echo "  - 15 seconds into gameplay"
-echo "  - 20 seconds into gameplay"
-echo "  - 25 seconds into gameplay"
-echo ""
-echo "For each capture:"
-echo "1. In Nsight, press F11 (or click 'Capture Frame')"
-echo "2. Save the capture with naming: unity_${SCENARIO}_capture_1.nsight"
-echo "   (increment number for each capture)"
-echo ""
-read -p "Press Enter to start timer..."
-
-# Timer for captures
-for i in {1..5}; do
-    TIME=$((i * 5))
-    echo ""
-    echo "Waiting for ${TIME} seconds..."
-    sleep 5
-    echo ">>> CAPTURE #${i} NOW! (Time: ${TIME}s) <<<"
-    echo "Press F11 in Nsight to capture"
-    echo "Save as: unity_${SCENARIO}_capture_${i}.nsight"
-    read -p "Press Enter when capture is saved..."
-done
-
-echo ""
-echo "Step 4: Export metrics"
-echo "---------------------"
-echo "In Nsight, for each capture:"
-echo "1. Open the capture file"
-echo "2. Go to GPU Trace or Performance view"
-echo "3. Export metrics to CSV"
-echo "4. Save as: unity_${SCENARIO}_capture_${i}_metrics.csv"
-echo ""
-read -p "Press Enter when exports are complete..."
-
-echo ""
-echo "Step 5: Take screenshots"
-echo "-----------------------"
-echo "Capture screenshots of:"
-echo "- GPU Timeline view"
-echo "- Memory analysis view"
-echo "- Any interesting performance bottlenecks"
-echo ""
-echo "Save screenshots to: screenshots/unity/${SCENARIO}/"
-echo ""
-read -p "Press Enter when screenshots are saved..."
-
-echo ""
-echo "✓ Testing complete for Unity - $SCENARIO_NAME"
-echo ""
-echo "Captured files:"
-echo "  - unity_${SCENARIO}_capture_1.nsight through unity_${SCENARIO}_capture_5.nsight"
-echo "  - unity_${SCENARIO}_capture_*_metrics.csv"
-echo "  - screenshots/unity/${SCENARIO}/*.png"
-echo ""
-echo "Next steps:"
-echo "1. Close Unity game"
-echo "2. Wait 2 minutes for system cooldown"
-echo "3. Run this script again or run: ./run_unreal_test.sh"
-echo "   to test the same scenario in Unreal Engine"
-echo ""

scripts/test_scenarios.md

@@ -1,6 +1,6 @@
 # Test Scenarios Document
 **Project**: Master's Thesis - Game Engine Performance Comparison  
-**Date**: January 16, 2026  
+**Date**: January 19, 2026  
 **Author**: Krzysztof Rudnicki  
 
 ---
@@ -13,12 +13,11 @@ This document defines the test scenarios for comparing Unity and Unreal Engine p
 
 ## Test Hardware
 
-*[Auto-generated by running: `./scripts/get_hardware_specs.sh`]*
-
-- **CPU**: [Your CPU model]
-- **GPU**: [Your GPU model]
-- **RAM**: [Your RAM amount]
-- **OS**: [Your OS version]
+- **CPU**: AMD Ryzen 9 7900X3D 12-Core Processor (24 cores, 48 threads)
+- **GPU**: NVIDIA GeForce RTX 3090 (24 GB GDDR6X)
+- **RAM**: 32 GB
+- **OS**: Arch Linux (kernel 6.18.5-arch1-1)
+- **NVIDIA Drivers**: 590.48.01
 
 ---
 
@@ -28,10 +27,15 @@ This document defines the test scenarios for comparing Unity and Unreal Engine p
 
 Both games implement identical gameplay mechanics:
 - Player-controlled ship
-- Enemy spawning system with escalating difficulty
+- Enemy spawning system with escalating load
 - Bullet pattern generation
 - Collision detection
-- 90-second survival mode
+- 90-second survival mode with progressive load increase
+
+> **Note**: The game runs continuously for 90 seconds with three load phases:
+> - **0-30 seconds**: Low load phase
+> - **30-60 seconds**: Medium load phase  
+> - **60-90 seconds**: High load phase
 
 ### Performance Metrics to Capture
 
@@ -44,16 +48,15 @@ Both games implement identical gameplay mechanics:
 
 ---
 
-## Test Scenarios
+## Load Phases
 
-### Scenario 1: Low Difficulty (Baseline)
+### Phase 1: Low Load (0-30 seconds)
 **Objective**: Establish baseline performance with minimal load
 
 **Parameters**:
 - **Bullet count on screen**: 50-100 bullets
 - **Active enemies**: 2-3 enemies
-- **Duration**: 30 seconds of gameplay
-- **Captures**: 5 frame captures at different moments
+- **Time window**: 0-30 seconds of gameplay
 
 **Expected Outcomes**:
 - Stable frame rate (60 FPS target)
@@ -61,22 +64,19 @@ Both games implement identical gameplay mechanics:
 - Minimal memory usage
 
 **Nsight Capture Points**:
-- 5 seconds into scenario
-- 10 seconds into scenario
-- 15 seconds into scenario
-- 20 seconds into scenario
-- 25 seconds into scenario
+- 10 seconds (early low load)
+- 20 seconds (stable low load)
+- 25 seconds (end of low load phase)
 
 ---
 
-### Scenario 2: Medium Difficulty
+### Phase 2: Medium Load (30-60 seconds)
 **Objective**: Test performance under moderate load
 
 **Parameters**:
 - **Bullet count on screen**: 200-300 bullets
 - **Active enemies**: 5-7 enemies
-- **Duration**: 30 seconds of gameplay
-- **Captures**: 5 frame captures at different moments
+- **Time window**: 30-60 seconds of gameplay
 
 **Expected Outcomes**:
 - Moderate GPU utilization (50-70%)
@@ -84,22 +84,19 @@ Both games implement identical gameplay mechanics:
 - Increased memory usage
 
 **Nsight Capture Points**:
-- 5 seconds into scenario
-- 10 seconds into scenario
-- 15 seconds into scenario
-- 20 seconds into scenario
-- 25 seconds into scenario
+- 35 seconds (transition to medium load)
+- 45 seconds (stable medium load)
+- 55 seconds (end of medium load phase)
 
 ---
 
-### Scenario 3: High Difficulty (Stress Test)
-**Objective**: Test performance under maximum load
+### Phase 3: High Load (60-90 seconds)
+**Objective**: Test performance under maximum load (stress test)
 
 **Parameters**:
 - **Bullet count on screen**: 500+ bullets
 - **Active enemies**: 10+ enemies
-- **Duration**: 30 seconds of gameplay
-- **Captures**: 5 frame captures at different moments
+- **Time window**: 60-90 seconds of gameplay
 
 **Expected Outcomes**:
 - High GPU utilization (>70%)
@@ -107,46 +104,38 @@ Both games implement identical gameplay mechanics:
 - Maximum memory usage observed
 
 **Nsight Capture Points**:
-- 5 seconds into scenario (system stabilizing)
-- 10 seconds into scenario (peak load)
-- 15 seconds into scenario (sustained load)
-- 20 seconds into scenario (peak load)
-- 25 seconds into scenario (sustained load)
+- 65 seconds (transition to high load)
+- 75 seconds (peak sustained load)
+- 85 seconds (end of high load phase)
 
 ---
 
 ## Data Collection Procedure
 
-### For Each Scenario:
+### For Each Test Run:
 
 1. **Pre-test Setup**:
-   - Close all background applications
-   - Disable system updates
-   - Set power mode to "High Performance"
-   - Wait 5 minutes for system stabilization
-   - Clear GPU/system caches
+   - Run `./scripts/close_background_apps.sh` to close unnecessary applications
+   - Verify system is idle
 
 2. **Unity Testing**:
-   - Launch Unity bullet-hell game
-   - Navigate to scenario (Low/Medium/High)
-   - Start NVIDIA Nsight Graphics
-   - Attach Nsight to Unity process
-   - Play scenario for 30 seconds
-   - Capture frames at designated time points (5 captures)
-   - Save capture data with naming: `unity_[scenario]_capture_[N].nsight`
-   - Export metrics to CSV: `unity_[scenario]_metrics.csv`
+   - Start NVIDIA Nsight Systems (`nsys-ui`)
+   - Configure Nsight to profile the Unity game executable
+   - Launch Unity bullet-hell game through Nsight
+   - Let the game run for full 90 seconds (all three load phases)
+   - Nsight captures performance data throughout the entire run
+   - Save capture data with naming: `unity_run_[N].nsight-rep`
+   - Export metrics to CSV: `unity_metrics_[N].csv`
 
 3. **Unreal Testing**:
    - Close Unity completely
-   - Wait 2 minutes for system cooldown
-   - Launch Unreal bullet-hell game
-   - Navigate to scenario (Low/Medium/High)
-   - Start NVIDIA Nsight Graphics
-   - Attach Nsight to Unreal process
-   - Play scenario for 30 seconds
-   - Capture frames at designated time points (5 captures)
-   - Save capture data with naming: `unreal_[scenario]_capture_[N].nsight`
-   - Export metrics to CSV: `unreal_[scenario]_metrics.csv`
+   - Start NVIDIA Nsight Systems (`nsys-ui`)
+   - Configure Nsight to profile the Unreal game executable
+   - Launch Unreal bullet-hell game through Nsight
+   - Let the game run for full 90 seconds (all three load phases)
+   - Nsight captures performance data throughout the entire run
+   - Save capture data with naming: `unreal_run_[N].nsight-rep`
+   - Export metrics to CSV: `unreal_metrics_[N].csv`
 
 4. **Post-test Data Organization**:
    - Organize captures in folders: `data/nsight/unity/` and `data/nsight/unreal/`
@@ -158,26 +147,26 @@ Both games implement identical gameplay mechanics:
 
 ## Expected Data Outputs
 
-### Per Test Run (15 total: 3 scenarios × 5 captures):
-- Nsight capture file (.nsight)
+### Per Test Run (3 runs per engine, 6 total):
+- Nsight capture file (.nsight-rep)
 - Metrics CSV with frame time, FPS, GPU %, memory, draw calls, vertices
-- Screenshot of Nsight GPU trace
+- Screenshot of Nsight GPU trace for each load phase
 - Screenshot of Nsight memory analysis
 
 ### Aggregate Data:
-- Comparison table: Unity vs Unreal per scenario
-- Performance graphs showing all metrics
-- Statistical analysis (mean, std dev, min, max)
+- Comparison table: Unity vs Unreal per load phase
+- Performance graphs showing all metrics over 90-second timeline
+- Statistical analysis (mean, std dev, min, max) per load phase
 
 ---
 
 ## Quality Assurance
 
 ### Validation Checks:
-- [ ] All scenarios tested in both engines
-- [ ] 5 captures per scenario completed
+- [ ] All three runs completed for Unity
+- [ ] All three runs completed for Unreal
 - [ ] All CSV metrics exported
-- [ ] Screenshots saved for all captures
+- [ ] Screenshots saved for all load phases
 - [ ] Data organized in proper folder structure
 - [ ] No system crashes or anomalies during testing
 - [ ] Comparable conditions between Unity and Unreal runs
@@ -192,21 +181,21 @@ Both games implement identical gameplay mechanics:
 
 ## Timeline
 
-- **Day 1 (Thursday, Jan 16)**: Setup Nsight, run Scenario 1 on both engines
-- **Day 2 (Friday, Jan 17)**: Run Scenario 2 on both engines
-- **Day 3 (Saturday, Jan 18)**: Run Scenario 3 on both engines
-- **Day 4 (Sunday, Jan 19)**: Verify data, re-run any problematic captures, organize data
+- **Day 1 (Sunday, Jan 19)**: Setup Nsight, run first test on Unity engine
+- **Day 2 (Monday, Jan 20)**: Complete Unity tests (3 runs), run first test on Unreal engine
+- **Day 3 (Tuesday, Jan 21)**: Complete Unreal tests (3 runs), verify data integrity
+- **Day 4 (Wednesday, Jan 22)**: Analyze results, create comparison graphs, organize data
 
 ---
 
 ## Notes
 
 - If a capture fails, note the reason and retry
-- Document any differences in how scenarios are triggered in Unity vs Unreal
+- Document any differences in how load phases manifest in Unity vs Unreal
 - Pay attention to engine-specific optimizations that may affect results
 - Consider recording video of test runs for reference
 
 ---
 
 **Status**: Ready for execution  
-**Next Action**: Run `./scripts/get_hardware_specs.sh` to generate hardware specs for Chapter 4
+**Next Action**: Run `./scripts/close_background_apps.sh` and start Nsight profiling