nyuuzyou/wikis huggingface dataset:
Decals in GIMP

= Overview =
This tutorial describes one process for making a decal in GIMP. GIMP 2.2 was used for these steps and images. Minor details may vary with other versions.
== Step 1: Creating a file ==
Create a new file, with the following settings:
* Width: 1024
* Height: 1024
* Colorspace: RGB Color (under advanced options)
* Fill with: Transparency (under advanced options)
The size can be varied but, since a decal is a material, it must conform to the size requirements for materials. In particular, each dimension must be a power of two. 
The size can be smaller (512x512, for example), but better results are often acquired by creating textures at their maximum resolution and later scaling them down as required for their in-game use.
== Step 2: Drawing ==
This step is completely up to you. Good results can be acquired from using various techniques, including:
* Custom brushes
* Photographic source material
* Scanned real-world materials 
== Step 3: Collapse all layers ==
* in the layers palette, right click on any layer and select "Merge Visible Layers..." to merge everything you have to one layer. If keeping the layers is important to you, you will want to save a copy of your file before doing this.
== Step 4: Opacity ==
Select everything you have drawn, in whatever way you prefer. I like using "select by color", setting the threshold very high, and clicking on a part of the image that I drew.
Now, right click on your layer in the layers palette, and select "Add Layer Mask". In the next dialog,
select "Selection", then click OK. You should see the mask show up beside your existing layer in the
Layers palette, and also if you open up the Channels palette, you should see the alpha channel there
with the appropriate mask. If you want to tweak the pixels in the alpha channel, now is the time to do
it; remember that black pixels indicate transparency (none of your pixels you drew will appear) and white
pixels indicate opaqueness (the full color of whatever you drew will show).
== Step 5: Saving ==
Before you save, go to the layers palette and click on the drawing part of your layer to deselect the layer mask. Pick also Select|None from the menus.
Go to File|Save As, and type in the filename that you want with a .tga extension. A dialog will pop up
telling you that TGA can't handle layer opacity or layer masks; just click Export. On the next dialog,
uncheck RLE compression.
That's all! Now you can make a material out of it. 
= Next step =
Now proceed to Creating Decals to complete the process.
= See also =
*Using Gimp for transparent materials
Category:Material System
Category:GIMP
Decals in Photoshop

Category:Tutorials Category:Material System
==Overview==
This tutorial describes one process for making a decal in Photoshop. Photoshop CS2 was used for these steps and images. Minor details may vary with other versions.
==Step 1: Creating a file==
Create a new file, with the following settings:
framed|none|Settings used in this tutorial
You may wish to create a preset with these options. The size can be varied but, since a decal is a material, it must conform to the size requirements for materials. In particular, each dimension must be a power of two. 
The size can be smaller (512x512, for example), but better results are often acquired by creating textures at their maximum resolution and later scaling them down as required for their in-game use.
If you select 16 bit, you will not be able to save as a .tga file, the image needed to create a material. If you don't select "Transparent", then the background will be white, which is not good, because it will lighten your decal.
==Step 2: Drawing==
This step is completely up to you. Good results can be acquired from using various techniques, including:
* custom Photoshop brushes
* photographic source material
* scanned real-world materials (for example, flicking ink onto blotting paper can produce a good starting point for a blood splatter decal).
In this example, a simple blood splatter has been drawn by hand.
thumb|300px|none|Sample decal
==Step 3: Opacity==
Hold down Ctrl and click on the thumbnail of your layer. This should select everything you have drawn.
Now, in the channels tab, click on "Create new channel". Your screen should look something like this:
thumb|300px|none|This is what your screen should look like now.
Press X then D to reset fill colors to default, then hold SHIFT and press F5. Accept the default settings in the pop up box. This will set the opacity of the selected part to what it corresponds to on your image. Click on the Layers Tab to see what the image will look like in game.
==Step 4: Saving==
Save it as a Targa file. The file must be saved in 32-bit format for the alpha channel to work.
thumb|300px|none|How to save your decal
That's all! Now you can make a material out of it.
==Next step==
Now proceed to Creating Decals to complete the process.
Decision Making Overview

From a high-level perspective, NPCs follow a fairly simple (and real-world logical) process for making decisions. The easiest way to understand it is to examine the basic outline first, and then dig further into the necessary exceptions afterwards.
Each time an NPC thinks, it follows this routine:
;Perform Sensing
:NPC Sensing generates a list of entities that it can see, and another list of NPC sounds that it can hear. The NPC ignores entities and sounds that it doesn't care about.
;Generate a list of Conditions
:Conditions are key pieces of information that the NPC will be using to make a decision. They are extracted from the sensed lists of entities & sounds, and from the state of the world and the NPC. Conditions might include:
:*I can see an enemy
:*I have taken some damage
:*My weapon's clip is empty
;Choose an appropriate State
:The State is the overall assessment of the NPC based upon the list of Conditions. For example:
:*NPCs with a visible enemy enter Combat
:*NPCs who have no enemies left will drop back to Alert
:*NPCs with a health of 0 would move to Dead
;Select a new Schedule if appropriate 
:The Schedule is the overall action being taken by the NPC, which is then broken down into Tasks (see below) for the NPC to actually perform. Schedules are chosen based upon the NPC's current State and Conditions. Examples might include:
:*I'm taking cover to reload my gun
:*I'm chasing after my enemy
:*I'm moving to a position where I have line-of-sight to my enemy
:NPCs will choose a new schedule for one of two reasons:
:#They finish performing their last schedule
:#They generate a condition that their current schedule has specified as an Interrupt
;Perform the current Task
:The Task is a component of a Schedule that describes a discrete action. Tasks must be performed one by one for the schedule to be completed. For example, the "I'm taking cover to reload my gun" schedule would be broken down into the following tasks:
:#Find a position to take cover at
:#Generate a path to that position
:#Run the path
:#Reload my gun
:Many tasks, like the one above, take time to perform, so the NPC will keep performing that task each time it thinks until the task is completed. Then, it'll move onto then next task in the current schedule, or pick a new schedule if there are no tasks left. If a task fails, the schedule fails. 
Category: AI
Decloak: Source

== Summary ==
 Decloak: Source a round-based mod with a simple core objective of escaping as the rebel team or defending an escape point as the combine. With the slight twist that the rebels can cloak to become completely invisible. The combine have a modified flashlight that can decloak the rebels when shone over them, rendering the the invisibility useless and allowing for massive carnage.
When all of this is mixed into a time based round with combine setting up barricades, SLAMs, Decloaking lights and turrets or rooting out and hunting down the rebels. This can be one crazy experience. Not to mention that rebels can gain upgrades off their fallen team mates.
== Features ==
* Rebel Cloaking device
* Rebel special weapon pickups
* Pickups from fallen team mates
* Combine Decloaking flashlight
** Combine standalone decloaking lights
* Combine Turret
* 2 training maps, similar to the HL1 Hazard Course
== The Team ==
: John Tsakok 
::- Creator, Lead coder
: David Miller 
::- Team lead, Webmaster, PR
: Mike "Townsend22" Townsend 
::- Lead mapper
: Tim "ultio" Eulitz 
::- Mapper, misc. assets
: Kristjan "BioĦaZarÐ" Skutta 
::- Animator
: Alex S. 
::- Sound design
: Hayden Carbis 
::- Network tester
: Tim "Ons1aught" Weyer 
::- Internal beta tester
== News ==
* Working on Beta 2. Which will fix most if not all bugs; have several new maps including the training, new weapons, the turret and other assorted stuff. Should be out about the end of the year.
== External links ==
* Decloak: Source (down) - Archived version - the official website.
* 
Category:Multiplayer Mods
Decompiling Maps

Category:Level Design
Category:Tutorials
Decompiling is the process of taking a compiled map file and generating a file that Hammer can open. Decompiled maps are not perfect recreations, because of format differences, loss of data (such as missing Func viscluster, and imprecise vertex position on complex brushes. This makes them useful for learning, measurement, and inspection, but not direct recompilation. The original source is ideal for reproductions or modifications.
Releasing reproductions, modifications, or approximations of another's work without permission nor credit may be considered rude to the author, is largely frowned upon, and is in fact copyright infringement, which may have legal consequences depending on the source of the map. There are methods of preventing maps from being fully decompiled (obfuscating textures, keeping entities or VScript server-side, etc.), but these are rarely used because most people who decompile maps are doing so to learn from them rather than to steal.
==Decompilers==
======
* (used to view the entities and other lumps on a map, decompiling to vmap, and exporting to glTF)
======
*EntSpy (used to view and edit the entities of a BSP without recompiling)
*BSPSource (open source map decompiler for Source engine maps, based on VMEX)
*VMEX (decompiler for Source engine maps)
*MapFool (helps porting HL1 maps to Source)
*xwad (command-line tool to convert texture formats)
======
* requires .NET Framework v1.1. (not recommended)
:
* requires .NET Desktop Runtime 6
* (not recommended)
* (not recommended)
* (not recommended)
* ( not recommended; recommended)
==Files==
Most maps do not need to be extracted, as they are located in the file system rather than VPK. The map files are normally located in a maps folder, for example common\Team Fortress 2\tf\maps\ holds all the official Team Fortress 2 maps.
==Before you go==
Before you take this jump to run off and decompile a map take a second or two to think, "What am I trying to learn/do?".
Read the included TXT files, you may just find the creator's e-mail, and that could be more helpful than you imagine.
Some mappers will offer help and advice, they may even go so far as to provide examples of what you wanted to borrow from the map.
==Porting newer maps to older Source games==
Decompiled maps from Left 4 Dead 2, Portal 2, Counter-Strike: Global Offensive, and Alien Swarm will crash when loaded in the Hammer for Half-Life 2, Team Fortress 2, Counter-Strike: Source, Day of Defeat: Source and other games. Opening the map in Left 4 Dead Hammer and re-saving it will automatically convert it to be compatible.
==See also==
*Porting GoldSrc content (maps, models, etc.) to Source
Category:Source
Decompiling a model

__NOTOC__
== Decompiling a model ==
*1. Click on the Decompile tab
*2. Select your model in the first top browse
*3. Select your working directory in the second top browse
*4. If you want to generate LOD tick the LOD mesh SMD files
*5. Click on Decompile
*6. Your model will be decompiled in your working directory it contains:
The mesh of your model in a smd file => animatic_truckclean_New_animclose_r.smd
The physics (the bounding box) in a smd => animatic_truckclean_physics.smd
The animations are stored in _anims folder => animatic_truckclean_anims
The qc file that will be use to compile a model => animatic_truckclean.qc
Defense of the Ancients

Defense of the Ancients (DotA Allstars or DotA; retroactively Dota 1) is a free mod which just a custom map for the . Some newer versions are compatible with and . It is a prequel to .
The developer of this game were later acquired by , in order to develop a sequel, called , around that time, there was a legal issue regarding the ownership of "DOTA" trademark, which Valve was sued by Blizzard. Both company settled in 2012, with Valve having the right to use "DOTA" IP commercially. Dota 2 was later released in 2013.
It heavily changed the gameplay without using many new assets.
The map has always had 3 lanes. Players call them the top, middle (or mid) and bottom (or bot), respectively.
== History ==
 had some unusual gameplay, but there were no major obstacles, destructible towers, fixed lanes, lane creeps which respawn for free, neutral creeps which respawn for free, Roshan, Runes, fountains.
 had a map Aeon of Strife by Aeon64.
 had a map Defense of the Ancients by Eul...
* 
* 
* 
- How popular is this game? What is its background?
- The basic core concept of the game stretches back almost 10 years to the early days of with a mod called Aeon of Strife and then afterwards with Valley of Dissent followed by RoC-DotA on Warcraft 3 by Euls. They had a relatively small but loyal playerbase. After the release of Warcraft 3: The Frozen Throne, many more mods of this concept took form. One of these was mods was DotA-Allstars, originally a collection of the most popular heroes from the other mods, initially developed by Meian followed by Guinsoo and then Neichus. Another DotA mod called DotA-Chaos was building up popularity in China at this time.
 
IceFrog's main focus and goals in the past 5 or so years have been to dramatically redesign and rebalance the original game concept and expand on it in order to make it a more enjoyable and engaging game for both casual and competitive players. In the last 2 years, the mod has seen an explosive increase in new players as well as acceptance into many e-sports organizations, growing from a few tens of thousands of players many years ago to the many millions of players it has right now. It is still growing more and more with each passing day.
 
I appreciate all the support and feedback that the fans provide, I would not have the motivation to develop this game every day without them.
== Trivia ==
* Latest and stable
- What is the difference between Latest Map and Stable Map
- The Latest Map always has new and experimental features. The Stable Map is the recommended version for tournament use. 
== Authors ==
* Ragn0r 
* Meian
* Icefrog
== External links ==
* http://www.dota-allstars.com - 
* http://www.getdota.com - 
* http://www.playdota.com -
* Hall of Fame -
* 
Category:Games on non-Valve engines using Valve IP
Defining the NPC

This page covers creating a simple NPC using the SDK's template.
== Setting up ==
All versions of the SDK (including Alien Swarm) provide a NPC template file at server/hl2/monster_dummy.cpp. You can copy this file to a new location and start working on it.
Change the model path in Precache() and Spawn() to a valid model file (choose something humanoid for now) and you will be able to spawn a NPC which turns to face sounds it hears nearby.
== Relationships ==
:This section targets the codebase.
An NPC's relationships define how it reacts to other NPCs. Use each NPC's FindEntityRelationship(CBaseEntity *pTarget) function to test the relationship state.
=== Dispositions ===
There are four built-in "dispositions":
* D_HATE
* D_FEAR
* D_LIKE
* D_NEUTRAL
Each relationship has a priority. The relationship with the highest priority wins if there is a conflict.
=== Targets ===
A relationship can target one of three things:
==== Faction ====
An NPC can belong to a faction, and that faction can have dispositions toward other factions. Factions are defined in game/shared/shareddefs.h (by default there are none).
; AddFactionRelationship()
: Adds a faction relationship for this NPC only.
; CBaseCombatCharacter::SetDefaultFactionRelationship()
: Adds a static faction relationship which is shared by all NPCs.
; ChangeFaction()
: Sets the faction to which the NPC belongs.
==== Class ====
An NPC can classify itself. This particular class is the return value of the Classify() function, and is not related to C++ or Hammer classes.
; AddClassRelationship()
: Adds a class relationship for this NPC only.
; CBaseCombatCharacter::SetDefaultRelationship()
: Adds a static class relationship which is shared by all NPCs.
; Class_T Classify()
: Returns this NPC's class.
Too add a new NPC class,go to basentity.h, line 95 and add you class.
==== Entity ====
Lastly, one-off relationships can be specified between any two NPCs.
; AddEntityRelationship()
: Adds a relationship between this NPC and another.
Category:AI Programming
Deja Vudu

Déjà Vudu is a mod where the player is trapped inside a mansion with voodoo spirits and must uncover the mysteries hidden in the surroundings. Déjà Vudu was developed in five months and uses adventure/puzzle game as its genre description.
The story begins when the player awakens inside a large abandoned plantation home on the outskirts of New Orleans. Armed with a possessed voodoo doll, the player gains the ability to travel through time. Inside the mysterious dwelling voodoo spirits, otherwise known as Loas, inhabit objects related to their personalities. Throughout the journey, the player uncovers tools that can be used to agitate the Loas. Once agitated, the Loas flee from the inhabited objects, thus allowing the player to capture them with the voodoo doll.
Déjà Vudu captures the essence of an environmental adventure. Every piece of the gameplay highlights the adventure aspect of the player’s experience, from exploration and discovery to tracking down and capturing spirits.
== External links ==
* Homepage at Guildhall
* Download
Delayed Attacks

== Overview ==
This tutorial will show you how to set up the Delayed Attack function to your weapon whether it's melee or fire arms. This should work with both Multiplayer and Singleplayer mods.
== Header ==
So add these new voids with in your weapon class.
void	DelayedAttack( void );
void	ItemPostFrame( void );
void	PrimaryAttack( void )	{ return;}
Now you may want to add these two in your weapon class.
private:
	bool m_bDelayedAttack;
	float m_flDelayedAttackTime;
If your Weapon doesn't have a constructor, add this after the DECLARE_CLASS.
	CWeaponDelayed();
== Weapon Script ==
Add two more headers within your weapon script if you haven't already. player and in_buttons.h will give you access to which buttons are being depressed by player
#include "player.h"
#include "basecombatcharacter.h"
#include "in_buttons.h"
	
Add the new variables with in your constructor.
CWeaponDelayed::CWeaponDelayed()
{
 m_bDelayedAttack = false;
 m_flDelayedAttackTime = 0.0f;
}
	
Next add the ItemPostFrame function if you don't already have one, if you do, just copy the content and place it with in your existing ItemPostFrame function.
void CWeaponDelayed::ItemPostFrame( void )
{
	CBasePlayer *pOwner = ToBasePlayer( GetOwner() );
	
	if ( pOwner == NULL )
		return;
	if ( (pOwner->m_afButtonPressed & IN_ATTACK) && !m_bDelayedAttack)
	{
		//Animation Comments
		//SendWeaponAnim( ACT_VM_HAULBACK );
		//m_flDelayedAttackTime = gpGlobals->curtime + SequenceDuration() + 1.0f;
		m_flDelayedAttackTime = gpGlobals->curtime + 1.0f;
		m_bDelayedAttack = true;
	}
	DelayedAttack();
	BaseClass::ItemPostFrame();
}
The rest should be easy to follow, all you have to do is place your primary fire code with in it.
void CWeaponDelayed::DelayedAttack( void )
{
 if (m_bDelayedAttack && gpGlobals->curtime > m_flDelayedAttackTime)
 {
		//Replace this Comment with Weapon Attack Function
		BaseClass::PrimaryAttack();
		m_bDelayedAttack = false;
 }
}
		
Category:Weapons programming
Category:Programming
Demoinfo2

demoinfo2.exe is a tool that will parse demo files (ending in .dem) and dump out every message in the demo. Using this tool, third parties can parse the demo for various game events to generate information and statistics.
You can download the binary and source code for demoinfo2.exe here.
You can use demoinfo2.exe by itself and parse the demo. We have also included the source code to the program itself to show how to parse and retrieve information directly.
Dota 2's demo format is built around using Google's Protocol Buffers (protobuf). Protobuf is a message/object serialization language that generates code to serialize the objects efficiently. If you wish to understand more about protobuf, check out http://code.google.com/p/protobuf/ 
In order to build demoinfo2 yourself, you will need Visual Studio 2010. You will also need to download Google's protobuf and snappy libraries.
* Extract demoinfo2.zip and it will make a new folder named "demoinfo2". 
* Download protobuf and install this directly in the protobuf-2.4.1 directory that was created when you extracted demoinfo2.
* Open protobuf-2.4.1\vsprojects\protobuf.sln into Visual Studio 2010. You will be asked to convert it, please do so. Once loaded, select Release version from the build target in the toolbar. Build the libprotobuf project by right clicking it in the solution list and hitting "build." You do not need to build the other protobuf projects. 
* Download protoc (the protobuf compiler) and extract this into the protoc-2.4.1-win32 folder that was created when you extracted demoinfo2. This is the protobuf compiler that parses .proto files and generates C++ code to parse the messages in the demo file.
* The last library needed is Google's snappy compression library. Download it from here and extract it into the snappy-1.0.5 folder.
Once those libraries are installed, you can now open demoinfo2.sln and build your own demoinfo2.exe binary. Select the Release build target from the toolbar and hit build! You will have a new binary in demoinfo2\Release\demoinfo2.exe.
To parse a demo, just download one in Dota 2. They will be in C:\Program Files (x86)\Steam\steamapps\common\dota 2 beta\dota\replays\*.dem. To dump a demo, just run "demoinfo2 xxx.dem" and it will print out all the messages in the demo.
Google's protobuf can generate parses in Java and Python using the same .proto files. People proficient in those languages can use protoc.exe to generate code that parses the protobuf messages and parse the demo file in those languages.
We are curious to see what people come up with using this tool and please do post questions and comments about it on the Replay section of the Dota 2 Development Forums.
Category:Dota 2