Skip to content

Using VScript as a HL2 mapper

Jump to bottom
Blixibon edited this page Jun 13, 2020 · 7 revisions

This article is for Half-Life 2/Source 2013 mappers who have no experience with VScript to learn what it is and how they can use it in their maps.

You don't need any previous programming experience to use VScript. VScript is only as complex as you want it to be.

There are three main ways in which VScript can be used in Mapbase:

Each of these sections have their own tutorial(s) which start as if you've never used VScript before.

Mapbase's implementation of VScript started with reductor's custom Squirrel integration and code ported from the Alien Swarm SDK; it has been expanded to include functions adjusted specifically for Half-Life 2-related purposes as well as some more access to Valve's mathlib and utility functions.

Using VScript to simplify map logic

Although VScript can make things very complex, it actually works really well for making things less complex.

Source's logic entities (and Mapbase's expansions to them) make the I/O system a flexible tool for doing complex things, like math or storage. However, this can get very complicated very quickly, as several different outputs fire several different inputs on several different entities as one big, messy jumble of icons in Hammer's 3D view.

VScript can be used to simplify these types of logic contraptions, as things like storing numbers, adding/subtracting numbers, finding entities, etc. can happen using just one line of text. This can be done to make map logic seem less complicated and sometimes it's actually necessary to reduce the level's entity count.

If you want to learn how to use VScript, it may be best to start by doing it alongside the I/O system. Click here to go to a tutorial on how you can use VScript to interact with the I/O system.

Using VScript to do what's not possible with I/O

A lot more can be done with VScript than what can normally be done with logic entities and I/O, even with Mapbase's enhancements.

While you can just use VScript to simplify map logic, it also unlocks a lot of potential in other areas. It's a pathway to many abilities some mappers would consider...unnatural. Of course, if you're already a programmer, then using this side of VScript may come naturally. If not, then it may seem a bit more complex, but if you think you can benefit from what it's capable of, then it would definitely be worth the trouble.

Click here to go to a tutorial which makes it simple and easy to understand.

Using VScript to modify game behavior

In some of Valve's games, VScript had unique abilities to modify game-specific behavior. This often replaced dedicated logic entities (e.g. tf_gamerules) or even the regular keyvalue-based scripts files.

For example, in Left 4 Dead 2, you can use VScript to influence or detect the behavior of the AI director which controls zombie spawning. This is often used to choreograph campaign finales.

Half-Life 2 doesn't have any of those kinds of complex built-in game systems, but Mapbase still adds hooks to modify certain HL2-related elements. For example, Mapbase adds NPC_TranslateActivity and NPC_TranslateSchedule hooks for modifying NPC behavior. NPC_TranslateActivity allows VScript to modify the animations a NPC plays during its AI without requiring scripted_sequence.

(TODO: Tutorial)

  • Something Index
    • Something special
    • Something else

Clone this wiki locally

, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '
Using VScript as a HL2 mapper · mapbase-source/source-sdk-2013 Wiki · GitHub
Skip to content
Using VScript as a HL2 mapper
Jump to bottom

Blixibon edited this page Jun 13, 2020
·
7 revisions
This article is for Half-Life 2/Source 2013 mappers who have no experience with VScript to learn what it is and how they can use it in their maps.
You don't need any previous programming experience to use VScript. VScript is only as complex as you want it to be.
There are three main ways in which VScript can be used in Mapbase:
Each of these sections have their own tutorial(s) which start as if you've never used VScript before.
Mapbase's implementation of VScript started with reductor's custom Squirrel integration and code ported from the Alien Swarm SDK; it has been expanded to include functions adjusted specifically for Half-Life 2-related purposes as well as some more access to Valve's mathlib and utility functions.
Using VScript to simplify map logic
Although VScript can make things very complex, it actually works really well for making things less complex.
Source's logic entities (and Mapbase's expansions to them) make the I/O system a flexible tool for doing complex things, like math or storage. However, this can get very complicated very quickly, as several different outputs fire several different inputs on several different entities as one big, messy jumble of icons in Hammer's 3D view.
VScript can be used to simplify these types of logic contraptions, as things like storing numbers, adding/subtracting numbers, finding entities, etc. can happen using just one line of text. This can be done to make map logic seem less complicated and sometimes it's actually necessary to reduce the level's entity count.
If you want to learn how to use VScript, it may be best to start by doing it alongside the I/O system. Click here to go to a tutorial on how you can use VScript to interact with the I/O system.
Using VScript to do what's not possible with I/O
A lot more can be done with VScript than what can normally be done with logic entities and I/O, even with Mapbase's enhancements.
While you can just use VScript to simplify map logic, it also unlocks a lot of potential in other areas. It's a pathway to many abilities some mappers would consider...unnatural. Of course, if you're already a programmer, then using this side of VScript may come naturally. If not, then it may seem a bit more complex, but if you think you can benefit from what it's capable of, then it would definitely be worth the trouble.
Click here to go to a tutorial which makes it simple and easy to understand.
Using VScript to modify game behavior
In some of Valve's games, VScript had unique abilities to modify game-specific behavior. This often replaced dedicated logic entities (e.g. tf_gamerules) or even the regular keyvalue-based scripts files.
For example, in Left 4 Dead 2, you can use VScript to influence or detect the behavior of the AI director which controls zombie spawning. This is often used to choreograph campaign finales.
Half-Life 2 doesn't have any of those kinds of complex built-in game systems, but Mapbase still adds hooks to modify certain HL2-related elements. For example, Mapbase adds NPC_TranslateActivity and NPC_TranslateSchedule hooks for modifying NPC behavior. NPC_TranslateActivity allows VScript to modify the animations a NPC plays during its AI without requiring scripted_sequence.
(TODO: Tutorial)
  • Something Index
    • Something special
    • Something else
Clone this wiki locally

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
Using VScript as a HL2 mapper · mapbase-source/source-sdk-2013 Wiki · GitHub
Skip to content
Using VScript as a HL2 mapper
Jump to bottom

Blixibon edited this page Jun 13, 2020
·
7 revisions
This article is for Half-Life 2/Source 2013 mappers who have no experience with VScript to learn what it is and how they can use it in their maps.
You don't need any previous programming experience to use VScript. VScript is only as complex as you want it to be.
There are three main ways in which VScript can be used in Mapbase:
Each of these sections have their own tutorial(s) which start as if you've never used VScript before.
Mapbase's implementation of VScript started with reductor's custom Squirrel integration and code ported from the Alien Swarm SDK; it has been expanded to include functions adjusted specifically for Half-Life 2-related purposes as well as some more access to Valve's mathlib and utility functions.
Using VScript to simplify map logic
Although VScript can make things very complex, it actually works really well for making things less complex.
Source's logic entities (and Mapbase's expansions to them) make the I/O system a flexible tool for doing complex things, like math or storage. However, this can get very complicated very quickly, as several different outputs fire several different inputs on several different entities as one big, messy jumble of icons in Hammer's 3D view.
VScript can be used to simplify these types of logic contraptions, as things like storing numbers, adding/subtracting numbers, finding entities, etc. can happen using just one line of text. This can be done to make map logic seem less complicated and sometimes it's actually necessary to reduce the level's entity count.
If you want to learn how to use VScript, it may be best to start by doing it alongside the I/O system. Click here to go to a tutorial on how you can use VScript to interact with the I/O system.
Using VScript to do what's not possible with I/O
A lot more can be done with VScript than what can normally be done with logic entities and I/O, even with Mapbase's enhancements.
While you can just use VScript to simplify map logic, it also unlocks a lot of potential in other areas. It's a pathway to many abilities some mappers would consider...unnatural. Of course, if you're already a programmer, then using this side of VScript may come naturally. If not, then it may seem a bit more complex, but if you think you can benefit from what it's capable of, then it would definitely be worth the trouble.
Click here to go to a tutorial which makes it simple and easy to understand.
Using VScript to modify game behavior
In some of Valve's games, VScript had unique abilities to modify game-specific behavior. This often replaced dedicated logic entities (e.g. tf_gamerules) or even the regular keyvalue-based scripts files.
For example, in Left 4 Dead 2, you can use VScript to influence or detect the behavior of the AI director which controls zombie spawning. This is often used to choreograph campaign finales.
Half-Life 2 doesn't have any of those kinds of complex built-in game systems, but Mapbase still adds hooks to modify certain HL2-related elements. For example, Mapbase adds NPC_TranslateActivity and NPC_TranslateSchedule hooks for modifying NPC behavior. NPC_TranslateActivity allows VScript to modify the animations a NPC plays during its AI without requiring scripted_sequence.
(TODO: Tutorial)
  • Something Index
    • Something special
    • Something else
Clone this wiki locally

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
Using VScript as a HL2 mapper · mapbase-source/source-sdk-2013 Wiki · GitHub
Skip to content
Using VScript as a HL2 mapper
Jump to bottom

Blixibon edited this page Jun 13, 2020
·
7 revisions
This article is for Half-Life 2/Source 2013 mappers who have no experience with VScript to learn what it is and how they can use it in their maps.
You don't need any previous programming experience to use VScript. VScript is only as complex as you want it to be.
There are three main ways in which VScript can be used in Mapbase:
Each of these sections have their own tutorial(s) which start as if you've never used VScript before.
Mapbase's implementation of VScript started with reductor's custom Squirrel integration and code ported from the Alien Swarm SDK; it has been expanded to include functions adjusted specifically for Half-Life 2-related purposes as well as some more access to Valve's mathlib and utility functions.
Using VScript to simplify map logic
Although VScript can make things very complex, it actually works really well for making things less complex.
Source's logic entities (and Mapbase's expansions to them) make the I/O system a flexible tool for doing complex things, like math or storage. However, this can get very complicated very quickly, as several different outputs fire several different inputs on several different entities as one big, messy jumble of icons in Hammer's 3D view.
VScript can be used to simplify these types of logic contraptions, as things like storing numbers, adding/subtracting numbers, finding entities, etc. can happen using just one line of text. This can be done to make map logic seem less complicated and sometimes it's actually necessary to reduce the level's entity count.
If you want to learn how to use VScript, it may be best to start by doing it alongside the I/O system. Click here to go to a tutorial on how you can use VScript to interact with the I/O system.
Using VScript to do what's not possible with I/O
A lot more can be done with VScript than what can normally be done with logic entities and I/O, even with Mapbase's enhancements.
While you can just use VScript to simplify map logic, it also unlocks a lot of potential in other areas. It's a pathway to many abilities some mappers would consider...unnatural. Of course, if you're already a programmer, then using this side of VScript may come naturally. If not, then it may seem a bit more complex, but if you think you can benefit from what it's capable of, then it would definitely be worth the trouble.
Click here to go to a tutorial which makes it simple and easy to understand.
Using VScript to modify game behavior
In some of Valve's games, VScript had unique abilities to modify game-specific behavior. This often replaced dedicated logic entities (e.g. tf_gamerules) or even the regular keyvalue-based scripts files.
For example, in Left 4 Dead 2, you can use VScript to influence or detect the behavior of the AI director which controls zombie spawning. This is often used to choreograph campaign finales.
Half-Life 2 doesn't have any of those kinds of complex built-in game systems, but Mapbase still adds hooks to modify certain HL2-related elements. For example, Mapbase adds NPC_TranslateActivity and NPC_TranslateSchedule hooks for modifying NPC behavior. NPC_TranslateActivity allows VScript to modify the animations a NPC plays during its AI without requiring scripted_sequence.
(TODO: Tutorial)
  • Something Index
    • Something special
    • Something else
Clone this wiki locally

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '
Using VScript as a HL2 mapper · mapbase-source/source-sdk-2013 Wiki · GitHub
Skip to content
Using VScript as a HL2 mapper
Jump to bottom

Blixibon edited this page Jun 13, 2020
·
7 revisions
This article is for Half-Life 2/Source 2013 mappers who have no experience with VScript to learn what it is and how they can use it in their maps.
You don't need any previous programming experience to use VScript. VScript is only as complex as you want it to be.
There are three main ways in which VScript can be used in Mapbase:
Each of these sections have their own tutorial(s) which start as if you've never used VScript before.
Mapbase's implementation of VScript started with reductor's custom Squirrel integration and code ported from the Alien Swarm SDK; it has been expanded to include functions adjusted specifically for Half-Life 2-related purposes as well as some more access to Valve's mathlib and utility functions.
Using VScript to simplify map logic
Although VScript can make things very complex, it actually works really well for making things less complex.
Source's logic entities (and Mapbase's expansions to them) make the I/O system a flexible tool for doing complex things, like math or storage. However, this can get very complicated very quickly, as several different outputs fire several different inputs on several different entities as one big, messy jumble of icons in Hammer's 3D view.
VScript can be used to simplify these types of logic contraptions, as things like storing numbers, adding/subtracting numbers, finding entities, etc. can happen using just one line of text. This can be done to make map logic seem less complicated and sometimes it's actually necessary to reduce the level's entity count.
If you want to learn how to use VScript, it may be best to start by doing it alongside the I/O system. Click here to go to a tutorial on how you can use VScript to interact with the I/O system.
Using VScript to do what's not possible with I/O
A lot more can be done with VScript than what can normally be done with logic entities and I/O, even with Mapbase's enhancements.
While you can just use VScript to simplify map logic, it also unlocks a lot of potential in other areas. It's a pathway to many abilities some mappers would consider...unnatural. Of course, if you're already a programmer, then using this side of VScript may come naturally. If not, then it may seem a bit more complex, but if you think you can benefit from what it's capable of, then it would definitely be worth the trouble.
Click here to go to a tutorial which makes it simple and easy to understand.
Using VScript to modify game behavior
In some of Valve's games, VScript had unique abilities to modify game-specific behavior. This often replaced dedicated logic entities (e.g. tf_gamerules) or even the regular keyvalue-based scripts files.
For example, in Left 4 Dead 2, you can use VScript to influence or detect the behavior of the AI director which controls zombie spawning. This is often used to choreograph campaign finales.
Half-Life 2 doesn't have any of those kinds of complex built-in game systems, but Mapbase still adds hooks to modify certain HL2-related elements. For example, Mapbase adds NPC_TranslateActivity and NPC_TranslateSchedule hooks for modifying NPC behavior. NPC_TranslateActivity allows VScript to modify the animations a NPC plays during its AI without requiring scripted_sequence.
(TODO: Tutorial)
  • Something Index
    • Something special
    • Something else
Clone this wiki locally

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
Using VScript as a HL2 mapper · mapbase-source/source-sdk-2013 Wiki · GitHub
Skip to content
Using VScript as a HL2 mapper
Jump to bottom

Blixibon edited this page Jun 13, 2020
·
7 revisions
This article is for Half-Life 2/Source 2013 mappers who have no experience with VScript to learn what it is and how they can use it in their maps.
You don't need any previous programming experience to use VScript. VScript is only as complex as you want it to be.
There are three main ways in which VScript can be used in Mapbase:
Each of these sections have their own tutorial(s) which start as if you've never used VScript before.
Mapbase's implementation of VScript started with reductor's custom Squirrel integration and code ported from the Alien Swarm SDK; it has been expanded to include functions adjusted specifically for Half-Life 2-related purposes as well as some more access to Valve's mathlib and utility functions.
Using VScript to simplify map logic
Although VScript can make things very complex, it actually works really well for making things less complex.
Source's logic entities (and Mapbase's expansions to them) make the I/O system a flexible tool for doing complex things, like math or storage. However, this can get very complicated very quickly, as several different outputs fire several different inputs on several different entities as one big, messy jumble of icons in Hammer's 3D view.
VScript can be used to simplify these types of logic contraptions, as things like storing numbers, adding/subtracting numbers, finding entities, etc. can happen using just one line of text. This can be done to make map logic seem less complicated and sometimes it's actually necessary to reduce the level's entity count.
If you want to learn how to use VScript, it may be best to start by doing it alongside the I/O system. Click here to go to a tutorial on how you can use VScript to interact with the I/O system.
Using VScript to do what's not possible with I/O
A lot more can be done with VScript than what can normally be done with logic entities and I/O, even with Mapbase's enhancements.
While you can just use VScript to simplify map logic, it also unlocks a lot of potential in other areas. It's a pathway to many abilities some mappers would consider...unnatural. Of course, if you're already a programmer, then using this side of VScript may come naturally. If not, then it may seem a bit more complex, but if you think you can benefit from what it's capable of, then it would definitely be worth the trouble.
Click here to go to a tutorial which makes it simple and easy to understand.
Using VScript to modify game behavior
In some of Valve's games, VScript had unique abilities to modify game-specific behavior. This often replaced dedicated logic entities (e.g. tf_gamerules) or even the regular keyvalue-based scripts files.
For example, in Left 4 Dead 2, you can use VScript to influence or detect the behavior of the AI director which controls zombie spawning. This is often used to choreograph campaign finales.
Half-Life 2 doesn't have any of those kinds of complex built-in game systems, but Mapbase still adds hooks to modify certain HL2-related elements. For example, Mapbase adds NPC_TranslateActivity and NPC_TranslateSchedule hooks for modifying NPC behavior. NPC_TranslateActivity allows VScript to modify the animations a NPC plays during its AI without requiring scripted_sequence.
(TODO: Tutorial)
  • Something Index
    • Something special
    • Something else
Clone this wiki locally

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
Using VScript as a HL2 mapper · mapbase-source/source-sdk-2013 Wiki · GitHub
Skip to content
Using VScript as a HL2 mapper
Jump to bottom

Blixibon edited this page Jun 13, 2020
·
7 revisions
This article is for Half-Life 2/Source 2013 mappers who have no experience with VScript to learn what it is and how they can use it in their maps.
You don't need any previous programming experience to use VScript. VScript is only as complex as you want it to be.
There are three main ways in which VScript can be used in Mapbase:
Each of these sections have their own tutorial(s) which start as if you've never used VScript before.
Mapbase's implementation of VScript started with reductor's custom Squirrel integration and code ported from the Alien Swarm SDK; it has been expanded to include functions adjusted specifically for Half-Life 2-related purposes as well as some more access to Valve's mathlib and utility functions.
Using VScript to simplify map logic
Although VScript can make things very complex, it actually works really well for making things less complex.
Source's logic entities (and Mapbase's expansions to them) make the I/O system a flexible tool for doing complex things, like math or storage. However, this can get very complicated very quickly, as several different outputs fire several different inputs on several different entities as one big, messy jumble of icons in Hammer's 3D view.
VScript can be used to simplify these types of logic contraptions, as things like storing numbers, adding/subtracting numbers, finding entities, etc. can happen using just one line of text. This can be done to make map logic seem less complicated and sometimes it's actually necessary to reduce the level's entity count.
If you want to learn how to use VScript, it may be best to start by doing it alongside the I/O system. Click here to go to a tutorial on how you can use VScript to interact with the I/O system.
Using VScript to do what's not possible with I/O
A lot more can be done with VScript than what can normally be done with logic entities and I/O, even with Mapbase's enhancements.
While you can just use VScript to simplify map logic, it also unlocks a lot of potential in other areas. It's a pathway to many abilities some mappers would consider...unnatural. Of course, if you're already a programmer, then using this side of VScript may come naturally. If not, then it may seem a bit more complex, but if you think you can benefit from what it's capable of, then it would definitely be worth the trouble.
Click here to go to a tutorial which makes it simple and easy to understand.
Using VScript to modify game behavior
In some of Valve's games, VScript had unique abilities to modify game-specific behavior. This often replaced dedicated logic entities (e.g. tf_gamerules) or even the regular keyvalue-based scripts files.
For example, in Left 4 Dead 2, you can use VScript to influence or detect the behavior of the AI director which controls zombie spawning. This is often used to choreograph campaign finales.
Half-Life 2 doesn't have any of those kinds of complex built-in game systems, but Mapbase still adds hooks to modify certain HL2-related elements. For example, Mapbase adds NPC_TranslateActivity and NPC_TranslateSchedule hooks for modifying NPC behavior. NPC_TranslateActivity allows VScript to modify the animations a NPC plays during its AI without requiring scripted_sequence.
(TODO: Tutorial)
  • Something Index
    • Something special
    • Something else
Clone this wiki locally

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();
Using VScript as a HL2 mapper · mapbase-source/source-sdk-2013 Wiki · GitHub
Skip to content
Using VScript as a HL2 mapper
Jump to bottom

Blixibon edited this page Jun 13, 2020
·
7 revisions
This article is for Half-Life 2/Source 2013 mappers who have no experience with VScript to learn what it is and how they can use it in their maps.
You don't need any previous programming experience to use VScript. VScript is only as complex as you want it to be.
There are three main ways in which VScript can be used in Mapbase:
Each of these sections have their own tutorial(s) which start as if you've never used VScript before.
Mapbase's implementation of VScript started with reductor's custom Squirrel integration and code ported from the Alien Swarm SDK; it has been expanded to include functions adjusted specifically for Half-Life 2-related purposes as well as some more access to Valve's mathlib and utility functions.
Using VScript to simplify map logic
Although VScript can make things very complex, it actually works really well for making things less complex.
Source's logic entities (and Mapbase's expansions to them) make the I/O system a flexible tool for doing complex things, like math or storage. However, this can get very complicated very quickly, as several different outputs fire several different inputs on several different entities as one big, messy jumble of icons in Hammer's 3D view.
VScript can be used to simplify these types of logic contraptions, as things like storing numbers, adding/subtracting numbers, finding entities, etc. can happen using just one line of text. This can be done to make map logic seem less complicated and sometimes it's actually necessary to reduce the level's entity count.
If you want to learn how to use VScript, it may be best to start by doing it alongside the I/O system. Click here to go to a tutorial on how you can use VScript to interact with the I/O system.
Using VScript to do what's not possible with I/O
A lot more can be done with VScript than what can normally be done with logic entities and I/O, even with Mapbase's enhancements.
While you can just use VScript to simplify map logic, it also unlocks a lot of potential in other areas. It's a pathway to many abilities some mappers would consider...unnatural. Of course, if you're already a programmer, then using this side of VScript may come naturally. If not, then it may seem a bit more complex, but if you think you can benefit from what it's capable of, then it would definitely be worth the trouble.
Click here to go to a tutorial which makes it simple and easy to understand.
Using VScript to modify game behavior
In some of Valve's games, VScript had unique abilities to modify game-specific behavior. This often replaced dedicated logic entities (e.g. tf_gamerules) or even the regular keyvalue-based scripts files.
For example, in Left 4 Dead 2, you can use VScript to influence or detect the behavior of the AI director which controls zombie spawning. This is often used to choreograph campaign finales.
Half-Life 2 doesn't have any of those kinds of complex built-in game systems, but Mapbase still adds hooks to modify certain HL2-related elements. For example, Mapbase adds NPC_TranslateActivity and NPC_TranslateSchedule hooks for modifying NPC behavior. NPC_TranslateActivity allows VScript to modify the animations a NPC plays during its AI without requiring scripted_sequence.
(TODO: Tutorial)
  • Something Index
    • Something special
    • Something else
Clone this wiki locally