notes.txt

todo:
auto time travel for making units
shoot stack behavior
taylor email has ui suggestions
tile iterators
check behavior when multiple players are superuser

sometimes still in replay mode after disconnect & reconnect
make auto aiming code smarter

make many paths then delete them lags w/ new resource calc algorithm (did it with old?)
to replace Player.newUnitSegments(), need to know timeStart and timeSimPast of unit (maybe units store reference to path)
way to unshare paths (preferably picking who goes where)
drawing path vis, unit path lines slow in big replays (moveCount = 53, segCount = 133, pathVisCount = 24, playerVisCount = 1)
share paths lags (but more important to share sniper paths than marine paths)
  having units selected, targeting in UpdateEvt are slow
if right click w/ sniper & miss, sniper moves (to bad place) instead of shoots (decrease click sensitivity?)
fix repeatedly making new paths in multiplayer (not fixed yet, probably failing canBeUnambiguousParent)
  update MakePathCmdEvt.pos
drag & drop in UI bar to set share paths seen order
multiple things w/ 1 unit, only 1 actually happens, decide which later on

things zach can work on (add him to copyright line)
  say ideas for first couple of levels, get min requirements from there
  mod files for scn
  mini map
  timeline
  superuser
  conventional fog of war (toggle)
  how will we do triggers?
    zach suggests tree/graph of dependencies
    run these in coroutines? save state like http://dotnet.agilekiwi.com/blog/2007/05/implementing-workflow-with-persistent.html
    dependency based system only has advantage over simpler event based system when event has >1 dependency
  level map
  memos and other messages
  main menu
  replay toggle
  profile scn_perf_test in pro trial?
look at starcraft 2 tutorial
stacking branch
  if building mine on mineral, path will contain (nonmoving) units of different type (mineral + mine)
  after merge
    if multiple types of events, rename SimEvt to TimedEvt?
    scoping using {}
    capitalize methods and make constants lowercase? (monodevelop says properties, such as protobuf-net ones, are supposed to be uppercase, but unity has them lowercase)
scenario branch
  arrows for making mine, building, new path
  only show toggle when there is a difference?
  find message on ground
github issue tracker
redundant may attack & take health code on sniper branch
different sniper units (not just paths) may have shot the unit
allow non-live sniper paths before they shoot (must change unseenAfter() and delete())
don't necessarily decouple UnitSprite from paths
click & drag line
queue multiple commands to make buildings
grouping units
right clicking when holding down n makes new paths going there
snap mine to closest mineral
move camera faster? (these should be moved into github issue like "UI suggestions/proposals")
consistent stacking unit order?
make paths of group should move new paths in formation?
unit tests? (http://blogs.unity3d.com/2013/12/18/unity-test-tools-released/ or https://github.com/zoon/nunit-unity3d or https://github.com/tenpn/untest)
  must justify 2x code complexity vs code review
  key is if find something broken, fix immediately
  maybe just start with removeUnit()
    returning SegmentUnits to remove would make this easier to unit test (may still need restoring code, otherwise would need to complicate resource check)
allow selecting any player, but giving commands only on human players?
attack command & animations
don't allow attacking while moving for some units
repair building command
way to make multiple paths at a time
don't make units come out in random directions?
allow selecting only 1 building at a time, and no units in addition?
sound
keep non-live paths in yellow areas w/o user help
darker gray tiles should act more conventionally
post to tigsource.com or unity forums?
unity 4.2
  quad primitive
    quad primitive doesn't display in player mode (output_log.txt says "The resource Quad.fbx could not be loaded from the resource file!")
  "Texture importer now has "Alpha is Transparency" setting, which does color dilation to fix edge artifacts on semitransparent textures. It is enabled by default for GUI textures."
  "fullscreen at native resolution" player setting"

levels: (not sure I like NSA as bad guy)
- tutorial
- find NSA's secret (big) hovering/floating datacenter in utah desert
  - have obvious toggle in replay to switch between what NSA sees and what you see (or NSA's replay and your replay)
  - mentor introduces quantum computers
- monty hall game with sharing paths?
- that was just a decoy, use sharing paths to find real, much bigger datacenter
  - datacenters mention successful missions to infiltrate each country, last one is the player's
- discover infiltration
  - emergency message from someone, about to say something classified but they get shot out of nowhere
  - agent from tutorial asks what's going on, some of player's units get shot out of nowhere
  - player discovers a ton of NSA units hiding in the corner, "all your data are belong to us"
  - NSA units seize the base but player picks up top secret replay
  - mentor describes virtual particles
- player's agency extracts sniper tech from replay
  - someone tries to leak location of an NSA base then gets shot (if player didn't figure it out yet)
- figure out to follow potential traitors
  - mentor describes double slit experiment
- identical units with different health?
  - mentor describes protons & neutrons identical under strong force
- sniper level
  - nsa insists on escorting everyone in building, so use sniper to kill escort and let you be unseen
  - on completion, get access to changing the past knowledge
- player's assignment changes to home country of spy agency, so can correct past mistakes
- introduce time travel (how exactly?)
  - mentor describes field/wavefunctions
- explore potentially infiltrated base, but there's no one hiding there and player becomes superuser
  - mentor says how nature controls/sees everything (1 player game) & how we measure it, describes path integral & wavefunction equivalence (or maybe save that for later)
  - email from US press secretary says US does not and will not infiltrate another countrys' bases, and as of today we can confirm that US has never infiltrated another country either! as part of president's transparency initiative, we are declassifying attached replay
    - mentor says replay only shows one way it could have happened (describe feynman diagrams here or later?)
- player gets to infiltrate another country's base, NSA style? (to introduce superuser-only commands)
  - if player fails to maintain superuser, other country's agents disappear and new one comes out of airport
- before simplify-rsc, we always deleted other paths after building building or mine b/c if another worker path did something then could get one or the other but not both, this frustrating limitation is decoherence/entanglement
- player's agency finds identical twin of cooperating NSA agent, use it to steal data (how exactly?)
  - mentor describes feynman diagrams (unless did so already)
  - leak says NSA is superuser by cheating, NSA has secret base at classified location that no one (not even in NSA) knows
- to find final NSA base, fill US map with new bases, last one says "Error: This location is already occupied", top secret NSA base appears there but requires superuser access
  - terminal opens suggesting to type "make me a sandwich", after refuses point out that google is your friend
  - use identical twin to get superuser access
  - then fail like regular make does before activating special NSA make
- final NSA base
  - has quantum computer and lots of virtual agents
  - leak things to press (or pick up quantum mechanics applications), on first leak all you data start belong to NSA at all other bases
  - mentor says something like quantum mechanics infiltrates every aspect of our lives (list some applications), so better get used to it
  - suggest donating :)
  - go to multiplayer lobby
- more ideas
  - teaming up with other players to mess around with 3rd player (field never really collapses)
  - allow negative min resources in 1 level to demonstrate decoherence
  - 0 vis radius to ask how we can measure anything
  - embed feynman qed videos somewhere
  - need more minerals (plausibility) by deadline but not enough, so modify past
    - what do we expect from the places we can't see?
  - standard model free build with feynman diagrams in background
    - mentor: correspondence btwn feynman diagrams and rts games

old changing the past and wavefunctions levels:
- what they didn't see
  - Matthew's 3/17/2013 email has alternate idea for 1st level
- better than a coin flip
- spreading coherence (objective is to see the entire map)
  - user controls electrons, but some antiprotons on map
  - after level introduce find enemy command to automate this in future
  - in q&a explain how nature controls/sees everything (1 player game) & how we measure it, interpretations of quantum mechanics
- retroactive coherence
- do I need another level to show applications of switching particles, or does 1st level show this well enough?
- somehow show how particle can be "coherent" even if not in yellow region
- make levels introducing economic parts of game after making sure they play well in multiplayer
...
- qubits? (might not need this level)
- lucky number computing
  - must introduce "waking up" concept before this level
- CPT level to annihilate the antiproton in negative 10 seconds (only enable CPT button for this level)
- thinking in the present
  - put introduction text in "what they didn't see" repeat
  - initially show detailed animation for each move command, then short animation retracing particle's movement every time after that

old paths levels: (find better synonym for "part 2" such as redux?)
- better than a coin flip, part 2
- spreading coherence, part 2
- retroactive coherence, part 2
- can introduce sharing paths between different unit types by having several hired guards of different nationalities/abilities
- snipers

alternate path implementations:
- if not concerned about performance (thanks to Benjamin, * are probably hardest)
  - storing history as actions might prevent state-space explosion
  - state: (set of units, map of player resources)
  - actions
  - step: (state, action) -> state
  - knowledge: (unit, owner, position)
  - assertion: (knowledge, state) -> bool
  - implies: action -> knowledge
  - multistate: set of [state] (i.e. full game state)
  - multiaction: (action, time)
  - *multistep: (multiaction, multistate) -> multistate
  - multiknowledge: (knowledge, time)
  - *prune: (set of multiknowledge, multistate) -> multistate
- since I need graph for good performance
  - graph traversal always imperative b/c nodes are fundamentally places
  - so make imperative global checker/pruner backed by functional local relations/assertions
- features that require storing history
  - replays of what "they see" (most important)
    - making then deleting nested paths in various orders seems to at least require tree, stacking requires graph
  - manual (not automatic) time travel
  - delete last path of unit
- if only concerned with the present, 90% of what the engine does is really easy to write, so if I also want replays & time travel does it really have to be that much harder?
- possible alternative: for each unit store parent(s) and every possible history of moves + children
  - make sure these aren't hard: identical units, figuring out what to copy, keeping copies (i.e. stacks) in sync
  - theory is move responsibility of delete paths (current hardest part) onto making & maintaining copies in alternate histories, since copying may be easier than figuring out whether shared data is needed elsewhere
    - doesn't simplify resource double-counting when multiple parents problem
  - determine whether units stacked by whether at same location
    - if too slow then cache Dictionary<FP.Vector, UnitPath> at timeSim & timeGame, recalculate whenever time changes
      - store nSeeUnits (for sharing paths) here
    - don't use path segments, would be tricky to keep in sync when deleting
  - when giving commands, make sure they're applied to all of unit's paths in stack
    - simple duplication: move, delete path, delete other paths
    - less simple: make unit, make path
    - stack is simple duplication when moving, but probably want to avoid duplicate StackEvts at same time
    - share paths needs to track nSeeUnits
  - what needs to be copied
    - moves
      - stacking onto moving unit requires new kind of timeStart, but don't need to support that right away
    - children
    - parents of children
  - copying unit tiles is hard, so instead store tiles per unit (not path) and use inVis() to check which paths of unit see there
  - delete other paths with identical units is something like if other units in stack seen elsewhere then delete other paths, need to define "seen elsewhere"
    - also true in current implementation if keep unit ids
    - if remove unit ids to make units truly indistinguishable, then counting parents is tricky

random notes:
- form 2 paths of same unit, then stack those paths is example of why merging paths must be handled directly (justifying stacking branch)
- phrase from AI wisdom: "expand selection by radius"
- retroactive visibility assumes units don't discontinuously disappear, so would require that paths move into another unit before being deleted (e.g. when another path of same unit is seen)
- tile coherence can be optimized in short term by only calculating it when unit moves onto the tile
  - if happening in present, only need to check that other players can't see the tile
- if I make units indistinguishable, Unit should point to segment it's on and replace SegmentUnit
  - pass identical checking methods as delegates to List.Find()
  - deleting other paths with indistinguishable units is tricky
- someone recommends binary space partitioning as general graphics optimizing technique
- company of heroes makes positioning important b/c resource gathering slow, low unit cap, controlling resource locations is important
- a goal of game can be stealing intelligence
- Matthew says have story or something to make game interesting for people not interested in "physics" q&a's
  - set story in future so can suspend disbelief less
- unit type ideas
  - don't need too many unit types b/c time travel & paths already make the game interesting
  - can have ranged units with visible laser paths
    - except can only see own snipers' laser paths (from all possible snipers)
    - other units' range is less than vis radius, so would be seen by the time they shoot (so ok for anyone to see laser path)
    - or use "bulleton" carrier particle?
  - healer? (not necessary to support switching units if disallow seeing health of other players' units)
  - can't have mines (they'd have to be visible to the opponent when in seeing range)
  - sniper unit that shoots further than visibility range (but can shoot units that other units see)
    - which sniper shot it?
    - reload slowly so not too powerful?
  - Matthew's unit images can be pixellated to keep them simple
  - workers/miners with low/0 attack (use as "helpers" in levels)
    - make more interesting name for them?
  - marines (generic shooting unit)
- light comes in packets if zoom in enough
- curved space/time manipulation (idea for new game)
  - time manipulation would be a great way to kill people by having them experience an infinite amount of time in the future (to us) in a finite amount of time (to them)
    - think Braid super-ring
  - can also have people "born" by experiencing infinite amount of time in past (to us) in finite amount of time (to them)
  - would have to be single player only (hard to sync clocks in multiplayer when they're going at different speeds)
  - time loops (become antimatter)

unity links:
student discount: https://www.studica.com/unity
external version control: https://docs.unity3d.com/Documentation/Manual/ExternalVersionControlSystemSupport.html
multiplayer tutorial: http://docs.unity3d.ru/Tutorials/M2H_Networking_Tutorial/M2H_Networking_Tutorial_Original.pdf
multiplayer project files: http://docs.unity3d.ru/Tutorials/M2H_Networking_Tutorial/M2H_Networking_Tutorial_Files.zip
binary serialization: https://code.google.com/p/protobuf-net/
protobuf-net unofficial manual: http://www.codeproject.com/Articles/642677/Protobuf-net-the-unofficial-manual
serialize at stream position: https://stackoverflow.com/questions/2441608/deserializing-a-type-at-the-current-stream-position-with-protobuf-net
2d: http://gamasutra.com/blogs/JoshSutphin/20130519/192539/Making_2D_Games_With_Unity.php
gui guide: https://docs.unity3d.com/Documentation/Components/GUIScriptingGuide.html
guilayout reference: https://docs.unity3d.com/Documentation/ScriptReference/GUILayout.html
memory (includes links to later parts): http://www.gamasutra.com/blogs/WendelinReich/20131109/203841/C_Memory_Management_for_Unity_Developers_part_1_of_3.php
use visual studio compiler: http://forum.unity3d.com/threads/120327-Video-Tutorial-How-to-use-Visual-Studio-for-all-your-Unity-development
pdb2mdb ienumerator fix: http://forum.unity3d.com/threads/161685-How-to-build-and-debug-external-DLLs/page2
fix monodevelop 4 tabbing: http://forum.unity3d.com/threads/191455-Tab-insanity-in-MonoDevelop-packaged-with-Unity-free#post1496147