nyuuzyou/wikis huggingface dataset:
Code Review

See the code with some (Github) comments on Github here (requires collaboration rights).
Notes from our code review (27 Mar 2014): The Item Interface
*who had a chance to look at this? Mostly everybody
*some style stuff—camel case, getters/setters
*length of an item: 
**what specifically does this refer to?
**more than one dimension?
**should not have a SET method
**should have a get method?
**is there any benefit to leaving it in?
**comment out and leave for later
**collisions vs. ray tracing – better, Unity already equipped to do this
*Item subparts – not really necessary for combat team, but crucial for item creation
*Item template with baseItem—infinite recursion loop?
**manage a private variable independently
**build an item from the top up or from the bottom down (recursive construct())
*overlayMaterials() – yellow feature
*mass computed based on materials
**Center of Mass concerns with Unity assuming a mesh is of uniform density
**components of the Material class
==Basic Workflow - Pull Requests==
Our team has decided to use the Github 'Shared Repository Model' centered around pull requests, which is explained by Github here. The process is as follows:
*Clone or update from the master branch
*Do all coding/work on a new local branch
*Commit changes with a specific description of your work to a new remote branch with the same name as your local branch (or commit to the existing remote branch with the same name if further changes need to be made after the code is reviewed)
*Open a pull request of your code compared with the master branch and have someone else review it. Note that we never merge our own code into the master branch. 
**Note: To notify a specific user of your pull request, type @<username> in the commit message and it will notify them of your pull request.
*The reviewer reviews the code (with or without the coder) and comments on any changes that need to be made. If the coder needs to make any changes to his code before it is merged into master, he commits those changes on the same branch he has been working on and has the reviewer look at all of the new code. 
*After all changes have been made to the coder's and reviewer's satisfaction, the reviewer merges the branch into master (manually if necessary), closes the pull request, and deletes the remote branch just reviewed.
----
Crafting

== Overview ==
The main draw of this game is being able to make custom objects that can be used in adventuring or sold to NPCs. This is a process with multiple steps, the most complicated of which is editing the shape of the item. These items are made from materials collected while adventuring and interacting with NPCs, and will have appearances which reflect the materials used, as well as the edits that the player has made. The quality of the completed items are determined by the skill of the craftsman and the type of materials used.
== Creating Magical Items ==
Magical items are created when something with magical properties is combined with the usual materials in the creation process. For example, using a piece of moon rock when forging a sword might create a magical moon sword. This would give the sword a unique aesthetic, as well as advantageous properties that have to do with moon magic. Creating magical items can be done in three different ways. They are as follows: 
# Magical material + item ingredients = magical item (as described above with the moon rocks). 
# Alchemical solution + item ingredients = magical item. 
# Rune combination + item ingredients = magical item.
=== A Note on Runes === 
Runes are not solely in the domain of the stonecutter. Anyone can learn runes. For example, the woodcarver could make a totem and carve a rune combo onto it for magical effects. One must simply learn the combo first. A weaver could weave a runic pattern into a cloak to give the cloak special properties.
=== List of Magical Materials ===
Magical materials include, but are not limited to:
* Dragon breath
* Dragon scales
* Moon rock
* Fallen Stars
* Trapped souls
* Ghost cry
* Pegasus feather
* Phoenix claw
* Tooth of Fenrir
* Hair from Sleipnir
* Freya’s Golden Apple
* Draugr Bones
* Mead from Valhalla
* Sun flare
* Water from Mimir’s well
* Jotun Belch
* Leaves of the World Tree
* Essence of Bifrost
* Heimdal’s eye
* Dwarf Stone
* Dragon teeth
* Draugr Talons
* Thor’s toenail clippings
* Odin’s Missing Eye
Exterior Level

The exterior level is small, but intended to be interesting enough to sell our world. It will be populated by pterodactyls. Here's the concept painting of the level:
Environment characteristics:
It is an island and will be surrounded by water and mist. 
I, Bryce, am hoping the pterodactyls will exhibit a particular behavior: that when the player approaches the pterodactyl eggs (which will be under the mushrooms), pterodactyls will swoop down from the trees to attack the player. If that's too complicated for the Kickstarter pitch, no problem. Everything else should take priority.
Item Creation Controller

=== Item Creation Controller ===
All interaction between the UI and the model will take place through a ModelUITranslator singleton/static class. This class will need to be able to perform the following operations on the model:
===Item Interface===
This is where we get the Item's geometry and other physical and decorative attributes.
Item Interface
===Controller Methods===
The controller modifies the Item's geometry and other attributes retrieved through the interface above.
*SetWeaponFacing(direction): called when the blade is flipped. The idea is that the model stores this as a necessary setting on many of these other calls. Alternatively, this could be a parameter to those methods.
*SetCurrentWeaponPart(weaponPart): indicates the user is now editing a different weapon part. Similarly to the above, this could be a parameter to pretty much all other methods instead.
*ChangeMaterial(weaponPart)
*InsertVertex(index, startPosition)
*DeleteVertex(vertexId)
*MoveVertex(vertexId, newPosition)
*ThickenWeapon(vertices)/FlattenWeapon(vertices): The result of the thicken/flatten tool. Thickens or flattens the portion of the blade corresponding to the set of vertices in the parameter (brings corresponding points closer to or further from the blade center). Happens in a set increment. Could be replaced by a single ChangeThickness(vertices, amount) method that accepts both positive and negative amount.
*PunchHole(position, radius, holeType): TODO: need a way to undo this method for undo/redo
*SetEdgeType(edgeType, vertexBefore, vertexAfter, lineStart, lineEnd): result of edge operations. Parameters specify an edge to operate on with the two vertices the edge is between, and the start and end positions of the line segment along that edge to apply the edge change to. TODO: would it be preferable to just apply edge operations to the entire length between two vertices?
*Fuller(isSubtract, shapeType, startPoint, endPoint): Applies fuller/drawing operations. TODO: should this be applied once to a line, or several times to successive points?
*SetCurve(): method signature TBD (low priority item)
Item Creation UI/Engine Interface

=== Item Creation Controller ===
All interaction between the UI and the model will take place through a ModelUITranslator singleton/static class. This class will need to be able to perform the following operations on the model:
===Item Interface===
This is where we get the Item's geometry and other physical and decorative attributes.
Item Interface
===Controller Methods===
The controller modifies the Item's geometry and other attributes retrieved through the interface above.
*SetWeaponFacing(direction): called when the blade is flipped. The idea is that the model stores this as a necessary setting on many of these other calls. Alternatively, this could be a parameter to those methods.
*SetCurrentWeaponPart(weaponPart): indicates the user is now editing a different weapon part. Similarly to the above, this could be a parameter to pretty much all other methods instead.
*ChangeMaterial(weaponPart)
*InsertVertex(index, startPosition)
*DeleteVertex(vertexId)
*MoveVertex(vertexId, newPosition)
*ThickenWeapon(vertices)/FlattenWeapon(vertices): The result of the thicken/flatten tool. Thickens or flattens the portion of the blade corresponding to the set of vertices in the parameter (brings corresponding points closer to or further from the blade center). Happens in a set increment. Could be replaced by a single ChangeThickness(vertices, amount) method that accepts both positive and negative amount.
*PunchHole(position, radius, holeType): TODO: need a way to undo this method for undo/redo
*SetEdgeType(edgeType, vertexBefore, vertexAfter, lineStart, lineEnd): result of edge operations. Parameters specify an edge to operate on with the two vertices the edge is between, and the start and end positions of the line segment along that edge to apply the edge change to. TODO: would it be preferable to just apply edge operations to the entire length between two vertices?
*Fuller(isSubtract, shapeType, startPoint, endPoint): Applies fuller/drawing operations. TODO: should this be applied once to a line, or several times to successive points?
*SetCurve(): method signature TBD (low priority item)
Item Effects

==Item Interface==
This page outlines the interface of the Item class, which behaves as the storage model for user-made custom items within the Artisan world. Instances of this class originate in the Item Creation Workshop / UI, and are used throughout the game world, notably in the combat system.
=== Attributes ===
The attributes that are inherent to each custom-created item.
 Since the game revolves around this unique part of gameplay, each of these attributes must be:
* Influenced by the item creation process
* Stored adequately in the item's internal representation in the program, and
* Useful or visible in the world outside the workshop, especially in combat; the item's custom nature (and perhaps also how it is used) are critical to determining the outcome of a combat situation.
Material
* Density:float (determines mass, speed) - this is an attribute of the materials used
* Hardness:float (determines armor-piercing ability) - also a material and treatment effect, alloys will affect this
* Toughness:float (how much shock can it take before it will break?)
* Flexibility:float (can it bend? How much? - yellow; more complex and maybe less useful in demo)
* Balance? (maybe determines speed of various parts of animations: easier to swing one way than another)
* Length:float (pure property of geometry. Longer weapons can hit from further away...what's the benefit of a shorter weapon? Less time required to strike.)
* Qualitative effects of the material used (i.e. elemental weaknesses, magical creatures being weak to iron, etc)
Geometry
GetMesh() : Mesh - This contains the Unity Mesh which has all of the Item's vertices, triangles, normals, etc. 2D editor to 3D model conversions will need to take place at the controller level.
* Sharpness:float (ditto; plus determined by geometry to some degree. Other methods can enhance sharpness)
** Edge Type:Enum (blunt, sharp (flat, convex, concave), serrated)
GetTemplate(): get the template the user chose (may be partly on the controller to pass this off)(Factory class for templates?)
GetWeaponParts() : Returns sub-Items grouped within this Item
GetBoundingBox(weaponPart): Returns a 2d polygon that specifies the bounding box for the current weaponPart in the current template
===Open Questions:===
How will the item be able to interact with the game world post-creation?
How will we incorporate these attributes into the creation process?
Item Interface

==Item Interface==
This page outlines the interface of the Item class, which behaves as the storage model for user-made custom items within the Artisan world. Instances of this class originate in the Item Creation Workshop / UI, and are used throughout the game world, notably in the combat system.
=== Attributes ===
The attributes that are inherent to each custom-created item.
 Since the game revolves around this unique part of gameplay, each of these attributes must be:
* Influenced by the item creation process
* Stored adequately in the item's internal representation in the program, and
* Useful or visible in the world outside the workshop, especially in combat; the item's custom nature (and perhaps also how it is used) are critical to determining the outcome of a combat situation.
Material
* Density:float (determines mass, speed) - this is an attribute of the materials used
* Hardness:float (determines armor-piercing ability) - also a material and treatment effect, alloys will affect this
* Toughness:float (how much shock can it take before it will break?)
* Flexibility:float (can it bend? How much? - yellow; more complex and maybe less useful in demo)
* Balance? (maybe determines speed of various parts of animations: easier to swing one way than another)
* Length:float (pure property of geometry. Longer weapons can hit from further away...what's the benefit of a shorter weapon? Less time required to strike.)
* Qualitative effects of the material used (i.e. elemental weaknesses, magical creatures being weak to iron, etc)
Geometry
GetMesh() : Mesh - This contains the Unity Mesh which has all of the Item's vertices, triangles, normals, etc. 2D editor to 3D model conversions will need to take place at the controller level.
* Sharpness:float (ditto; plus determined by geometry to some degree. Other methods can enhance sharpness)
** Edge Type:Enum (blunt, sharp (flat, convex, concave), serrated)
GetTemplate(): get the template the user chose (may be partly on the controller to pass this off)(Factory class for templates?)
GetWeaponParts() : Returns sub-Items grouped within this Item
GetBoundingBox(weaponPart): Returns a 2d polygon that specifies the bounding box for the current weaponPart in the current template
===Open Questions:===
How will the item be able to interact with the game world post-creation?
How will we incorporate these attributes into the creation process?
Load OBJ

We now have a .obj file parser pushed to our repository. If you want to see the source code for yourself, it can be located here on github.
Instructions for use:
*Reference the .dll or reference the project directly as usual.
*Create the ObjLoaderFactory object:
 
 var objLoaderFactory = new ObjLoaderFactory();
 var objLoader = objLoaderFactory.Create();
 
*Open .obj file with a FileStream object (remember to surround with a try/catch):
 
 var fileStream = new FileStream("model.obj",FileMode.Open);
 var result = objLoader.Load(fileStream);
 
The LoadResult object contains the loaded model in this form:
	
 
 public class LoadResult 
 {
 public IList<Vertex> Vertices { get; set; }
 public IList<Texture> Textures { get; set; }
 public IList<Normal> Normals { get; set; }
 public IList<Group> Groups { get; set; }
 public IList<Material> Materials { get; set; }
 }
Milestones

== Current Milestones ==
Project milestones are currently dictated by the CS428 schedule.
Due Date	Description 	Completed / Link
Jan 16 	Publicly Accessible Project Wiki 	Posted (This page!)
Jan 23 	Organization Chart - Our roles 	Org Chart
Jan 30 	Requirements Document - What we will need to do 	Project Requirements
Feb 6 	Pert and Gantt Charts - Project timeline and status 	Project Timeline
Feb 13 	Source Control System - Online codebase 	Source Control System (Note: requires collaboration rights)
Feb 20 	Design documents reviewed (Not a 428-related milestone) 	Project Design
Feb 27 	Code Review 	Code Review
Mar 6 	Test Specification 	Test Specification
Mar-Apr 	None (Here's where we can put in our own milestones if we find we need any)	...
Apr 15 	Project Video 	Project Video
May 15 	Kickstarter Pitch (In conjunction with the video) - date subject to change.	Kickstarter Pitch
== Project Features ==
Because the demo is to be developed in the course of a semester, essential features have been enumerated with their priority. It is anticipated that enough features will be completed to allow the project to be pitched on Kickstarter.
New Project Requirements

These requirements are in place as of 19 Mar 2014:
==Exterior Level==
	Imported assets with physics implemented
	
		Skybox, island, trees, beach, ruins, reeds, boat (all assets but trees are done)
		
			set trees to be bendable
		
	
	Background music (already composed, now being arranged, recorded)
	Sound effects
		
			wind
			water/waves
			footsteps on grass
			footsteps on sand
			footsteps on stone
			sword hit
			biter beak hit
		
	Wind zone
	
		Set tree bend in tree editor
	
	Snowfall particle generator
==Animated characters:==
	Hallstein mesh and texture
	
		Animations (there may be free animations available at Unity Asset Store)
		
			idle
			walk
			attack 1
			attack 2
			damage recoil
			jump?
			Hammering on anvil (for forge)
		
			
		Sound effects
		
			damage grunt
			attack grunt
			jump grunt?
		
		
	
	Biter mesh and texture
	
		i. Animations
		
			idle
			take off
			flight
			attack
			death
		
		
		Sound effects
		
			attack screech
			damage screech
			flapping wings?
		
	
==Item creation:==
	Edit 3D sword mesh within Unity
	
		Demonstratable
		have buttons that can utilize graphics designed for project
		be able to use edited sword in game
		If there's time, make an option to choose another material to make the blade out of and show the color change
	
==Forge environment:==
 
 simple backdrop with stump, anvil, and other props.
	Implement character with hammering animation.
	Have a location to click that initiates item creation process
	sound effects
 
	 fire crackle
	 hammering
 
 
</P>
Project Design

==Project Design==
Link to design pages below for each aspect of the project derived from the requirements found on the Project Requirements page.
===Item Interface===
How does the Item affect gameplay, particularly combat? What can you change about it that will influence this?
Item Interface
===Item Creation UI Design===
Assigned: Ben Williams, Mark Siebert, Eric Hullinger
Item Creation UI Design
Item Creation Controller (Connects to the Item Interface to modify the Item's attributes and geometry)
===Item Creation Engine Design===
Assigned: Seth Stewart, Matt Hess
Item Creation Engine Design
===Combat System Design===
Assigned: Spencer Kropp, David Boudreau, Nathan Standiford
Combat System Design
Combat UI Design
Combat Animation Design
===Gameplay Design===
Assigned: Nathan Standiford
Rendering Design
===Character Attributes===
Character Attributes
Random Ideas

===Ideas, Questions, Comments===
(Seth Stewart)
* Items created by players could be made available on an online marketplace, where you can buy and sell from other players and acquire items for your game. 
* You can also export 3D-printable models of your creations and through an online service have them printed and shipped to you for a small fee
* If we can team up with an actual smithy or craft studio, you could remotely machine or commission an artist to create your game world item and deliver the actual thing (sword, buckler, helmet, pendant, etc.) to your door!
(Mark Siebert)
* LAN play - one if my favorite things is during around playing LAN games with my siblings. It's good bonding time.
* Traveling merchants in Towns are other players. A player could opt to sell some of his items, and his avatar would show up in someone else's town to sell the items.
* Global market place
* wonder trade of items - newest Pokemon games have 'wonder trade' which basically randomly pairs the items two players have offered for trade and trades them. Super fun.
* Procedural generation is a big deal these days. Could we pull that off when we create the world? I mean, obviously, there will be certain locations that have to exist (the city, the lair of the dragon, etc.), but they could be variable in size and design as well.
* Randomly generated quests (like Skyrim) (I guess I'm just into the idea that no two playthroughs are the same)
(David Boudreau)
* Make it like Zelda, without level and combat classes; in my opinion, different types of armor can be different, but two different types of plate armor should be very similar if not exactly the same (the only difference should be your character’s appearance)
* I think anyone ought to be able to learn any ability; it might be fun to make it a mystery as to how you would obtain some abilities, or even what abilities can be obtained
* Make it skill-based combat, where the point isn’t to live longer than the creature you are fighting (hp-based), but to understand exactly how it fights and to counter its every move
** On this note, there can be both offensive and defensive abilities for all types of combat
** There should never be any passive abilities; all abilities ought to be active
* I think that combat specialization is important, but common rpg’s have taken the wrong direction with it. In coop, you ought to be surprised by the amount of different things other people can do. 
* Combat ought to have an effect on the environment, and the environment ought to have an effect on the combat. 
** For example, if you’re fighting in a mansion, and the enemy is standing under a chandelier, well I think you can figure out the rest.
** If there is a fire sorcerer in a forest (whether enemy or foe), the forest should start to catch on fire wherever his fire spells land.
Rendering Design

UDK 3.0 uses the Gemini rendering engine:
Unreal Engine 3’s multi-threaded rendering system, Gemini, gives you a 64-bit HDR rendering pipeline. The raw power behind Unreal Engine 3’s rendering system will push your creations to new levels. Your work has never seemed as alive as it is with Unreal Engine 3.
Unreal Engine 3 brings you Gemini, the multi-threaded rendering system. Gemini creates a lush visual reality and provides the power necessary for photorealistic simulations. Deliver stunning results with this flexible and highly optimized renderer.
Link
==Lighting==
===Global Illumination===
UDK 3.0 has lightmass, which is a global illumination solver:
Illuminate your world with Unreal Engine 3’s advanced game lighting and shadowing system, screen space ambient occlusion and Unreal Lightmass, the global illumination solver yielding high-quality static lighting and effects. Unreal Engine 3 supports all modern per-pixel lighting and rendering techniques as well as custom, artist-controlled per-material lighting models.
Link
===Light Rigs===
Light rigs should be constructed for the exterior, interior, and characters. Additionally, light linking should be performed on each object to avoid light pollution. Should we do this?
===Ambient Occlusion===
To simplify shading, the game will support ambient occlusion.
==Shading==
===Textures===
* What should we support as the maximum texture size (I've read we can raise it to 4096x4096)?
==Review & Feedback==
It looks like UDK's lighting/shading will be a good tool for rendering the forge and the external environment. There are still some question marks in some parts of this page, I say just decide what you want to do with each of them and go for it.