Filters

Jump to bottom
Blixibon edited this page Jun 27, 2020 · 9 revisions

A filter tests a certain condition or set of conditions to filter through entities, like a trigger_once using a filter_activator_name that only allows an entity with the name "cow" to pass it. Click here for more information on filters in Source.

In Mapbase, all filters have been given the following new I/O/KV:

Inputs

  • TestEntity<ehandle> - Tests the filter against the specified entity and fires OnPass or OnFail based on the result. (TestActivator only uses the activator)
  • SetField<any> - Sets this filter's primary testing criteria (e.g. the name to test against the activator).

KeyValues

  • Pass caller when tested<boolean> - When tested with TestActivator or TestEntity, this causes the OnPass and OnFail outputs to use the entity that called the test as the caller instead of the filter itself.

New filters

Mapbase adds a few new filters so mappers could test more conditions:

NameDescription
filter_activator_modelFilters an entity by its model's name. This entity already exists in all games starting with Left 4 Dead, but Mapbase adds the option to filter by skin and supports matchers.
filter_activator_contextFilters an entity by its response contexts. This entity already exists in all games starting with Left 4 Dead, but Mapbase allows for multiple contexts to be used at once and supports matchers.
filter_activator_squadFilters an NPC by its squad name, with the option to deny silent members. (enemy finders, vital allies in player_squad, etc.)
filter_activator_hintgroupFilters an NPC by its hint group, with the option to filter Hint Limit Nav.
filter_activator_keyfieldFilters an entity by its keyvalues, serving as an extension of logic_keyfield.
filter_activator_relationshipFilters an entity by its relationship to a target, or vice versa.
filter_activator_classifyFilters an entity by its Classify() class. (e.g. CLASS_PLAYER_ALLY)
filter_activator_criteriaFilters an entity by response criteria normally used in the response system.
filter_activator_involumeFilters an entity by whether it's inside of a target entity's volume. (e.g. a trigger)
filter_activator_surfacedataFilters an entity by its surface data. (e.g. whether it's made of wood)

Redirect filters

Redirect filters are a new "class" of filters that take a separate entity from the activator and pass it to another filter. For example, a trigger_once using a filter_redirect_weapon gets the activator's weapon and passes it to a filter_activator_class, which checks if it's a weapon_pistol.

Here's a list of the redirect filters introduced in Mapbase:

NameDescription
filter_redirect_weaponRedirects the activator's weapon. When used as a damage filter, this gets the weapon used in the damage.
filter_redirect_ownerRedirects the activator's owner entity.
filter_redirect_inflictorAs a damage filter, this redirects the inflictor of the damage, e.g. the grenade in an explosion. (filters normally use the attacker)

Damage manipulators

Damage manipulators are a family of filters designed to be used as damage filters, directly manipulating or operating with damage in some way. They don't actually filter anything themselves, but they can use a "secondary filter" to act as an actual damage filter or to control their behavior.

4 of these entities exist in Mapbase:

NameDescription
filter_damage_transferCauses damage taken by entities using this filter to transfer to a different entity, or a set of entities.
filter_damage_modModifies damage taken by entities using this filter.
filter_damage_logicFires outputs with damage parameters whenever an entity using this filter takes damage.
filter_blood_controlControls whether blood can be emitted when an entity using this filter takes damage. (does not affect actual damage on its own)

filter_script

filter_script is a special filter which allows filter functions to be controlled by VScript. See VScript in Mapbase for more information on VScript.

Here's a list of the hooks filter_script can use:

SignatureDescription
bool PassesFilter(handle caller, handle entity)Check if the given caller and entity pass the filter.
bool PassesDamageFilter(handle caller, handle info)Check if the given caller and damage info pass the damage filter.
bool PassesFinalDamageFilter(handle caller, handle info)Used by filter_damage_redirect to distinguish between standalone filter calls and actually damaging an entity. Returns true if there's no unique behavior.
bool BloodAllowed(handle caller, handle info)Check if the given caller and damage info allow for the production of blood.
bool DamageMod(handle caller, handle info)Mods the damage info with the given caller.
  • 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" + '

Skip to content
Filters
Jump to bottom

Blixibon edited this page Jun 27, 2020
·
9 revisions
A filter tests a certain condition or set of conditions to filter through entities, like a trigger_once using a filter_activator_name that only allows an entity with the name "cow" to pass it. Click here for more information on filters in Source.
In Mapbase, all filters have been given the following new I/O/KV:
Inputs
  • TestEntity<ehandle> - Tests the filter against the specified entity and fires OnPass or OnFail based on the result. (TestActivator only uses the activator)
  • SetField<any> - Sets this filter's primary testing criteria (e.g. the name to test against the activator).
KeyValues
  • Pass caller when tested<boolean> - When tested with TestActivator or TestEntity, this causes the OnPass and OnFail outputs to use the entity that called the test as the caller instead of the filter itself.
New filters
Mapbase adds a few new filters so mappers could test more conditions:
NameDescription
filter_activator_modelFilters an entity by its model's name. This entity already exists in all games starting with Left 4 Dead, but Mapbase adds the option to filter by skin and supports matchers.
filter_activator_contextFilters an entity by its response contexts. This entity already exists in all games starting with Left 4 Dead, but Mapbase allows for multiple contexts to be used at once and supports matchers.
filter_activator_squadFilters an NPC by its squad name, with the option to deny silent members. (enemy finders, vital allies in player_squad, etc.)
filter_activator_hintgroupFilters an NPC by its hint group, with the option to filter Hint Limit Nav.
filter_activator_keyfieldFilters an entity by its keyvalues, serving as an extension of logic_keyfield.
filter_activator_relationshipFilters an entity by its relationship to a target, or vice versa.
filter_activator_classifyFilters an entity by its Classify() class. (e.g. CLASS_PLAYER_ALLY)
filter_activator_criteriaFilters an entity by response criteria normally used in the response system.
filter_activator_involumeFilters an entity by whether it's inside of a target entity's volume. (e.g. a trigger)
filter_activator_surfacedataFilters an entity by its surface data. (e.g. whether it's made of wood)
Redirect filters
Redirect filters are a new "class" of filters that take a separate entity from the activator and pass it to another filter. For example, a trigger_once using a filter_redirect_weapon gets the activator's weapon and passes it to a filter_activator_class, which checks if it's a weapon_pistol.
Here's a list of the redirect filters introduced in Mapbase:
NameDescription
filter_redirect_weaponRedirects the activator's weapon. When used as a damage filter, this gets the weapon used in the damage.
filter_redirect_ownerRedirects the activator's owner entity.
filter_redirect_inflictorAs a damage filter, this redirects the inflictor of the damage, e.g. the grenade in an explosion. (filters normally use the attacker)
Damage manipulators
Damage manipulators are a family of filters designed to be used as damage filters, directly manipulating or operating with damage in some way. They don't actually filter anything themselves, but they can use a "secondary filter" to act as an actual damage filter or to control their behavior.
4 of these entities exist in Mapbase:
NameDescription
filter_damage_transferCauses damage taken by entities using this filter to transfer to a different entity, or a set of entities.
filter_damage_modModifies damage taken by entities using this filter.
filter_damage_logicFires outputs with damage parameters whenever an entity using this filter takes damage.
filter_blood_controlControls whether blood can be emitted when an entity using this filter takes damage. (does not affect actual damage on its own)
filter_script
filter_script is a special filter which allows filter functions to be controlled by VScript. See VScript in Mapbase for more information on VScript.
Here's a list of the hooks filter_script can use:
SignatureDescription
bool PassesFilter(handle caller, handle entity)Check if the given caller and entity pass the filter.
bool PassesDamageFilter(handle caller, handle info)Check if the given caller and damage info pass the damage filter.
bool PassesFinalDamageFilter(handle caller, handle info)Used by filter_damage_redirect to distinguish between standalone filter calls and actually damaging an entity. Returns true if there's no unique behavior.
bool BloodAllowed(handle caller, handle info)Check if the given caller and damage info allow for the production of blood.
bool DamageMod(handle caller, handle info)Mods the damage info with the given caller.
  • 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('^' + ".*" + '

Skip to content
Filters
Jump to bottom

Blixibon edited this page Jun 27, 2020
·
9 revisions
A filter tests a certain condition or set of conditions to filter through entities, like a trigger_once using a filter_activator_name that only allows an entity with the name "cow" to pass it. Click here for more information on filters in Source.
In Mapbase, all filters have been given the following new I/O/KV:
Inputs
  • TestEntity<ehandle> - Tests the filter against the specified entity and fires OnPass or OnFail based on the result. (TestActivator only uses the activator)
  • SetField<any> - Sets this filter's primary testing criteria (e.g. the name to test against the activator).
KeyValues
  • Pass caller when tested<boolean> - When tested with TestActivator or TestEntity, this causes the OnPass and OnFail outputs to use the entity that called the test as the caller instead of the filter itself.
New filters
Mapbase adds a few new filters so mappers could test more conditions:
NameDescription
filter_activator_modelFilters an entity by its model's name. This entity already exists in all games starting with Left 4 Dead, but Mapbase adds the option to filter by skin and supports matchers.
filter_activator_contextFilters an entity by its response contexts. This entity already exists in all games starting with Left 4 Dead, but Mapbase allows for multiple contexts to be used at once and supports matchers.
filter_activator_squadFilters an NPC by its squad name, with the option to deny silent members. (enemy finders, vital allies in player_squad, etc.)
filter_activator_hintgroupFilters an NPC by its hint group, with the option to filter Hint Limit Nav.
filter_activator_keyfieldFilters an entity by its keyvalues, serving as an extension of logic_keyfield.
filter_activator_relationshipFilters an entity by its relationship to a target, or vice versa.
filter_activator_classifyFilters an entity by its Classify() class. (e.g. CLASS_PLAYER_ALLY)
filter_activator_criteriaFilters an entity by response criteria normally used in the response system.
filter_activator_involumeFilters an entity by whether it's inside of a target entity's volume. (e.g. a trigger)
filter_activator_surfacedataFilters an entity by its surface data. (e.g. whether it's made of wood)
Redirect filters
Redirect filters are a new "class" of filters that take a separate entity from the activator and pass it to another filter. For example, a trigger_once using a filter_redirect_weapon gets the activator's weapon and passes it to a filter_activator_class, which checks if it's a weapon_pistol.
Here's a list of the redirect filters introduced in Mapbase:
NameDescription
filter_redirect_weaponRedirects the activator's weapon. When used as a damage filter, this gets the weapon used in the damage.
filter_redirect_ownerRedirects the activator's owner entity.
filter_redirect_inflictorAs a damage filter, this redirects the inflictor of the damage, e.g. the grenade in an explosion. (filters normally use the attacker)
Damage manipulators
Damage manipulators are a family of filters designed to be used as damage filters, directly manipulating or operating with damage in some way. They don't actually filter anything themselves, but they can use a "secondary filter" to act as an actual damage filter or to control their behavior.
4 of these entities exist in Mapbase:
NameDescription
filter_damage_transferCauses damage taken by entities using this filter to transfer to a different entity, or a set of entities.
filter_damage_modModifies damage taken by entities using this filter.
filter_damage_logicFires outputs with damage parameters whenever an entity using this filter takes damage.
filter_blood_controlControls whether blood can be emitted when an entity using this filter takes damage. (does not affect actual damage on its own)
filter_script
filter_script is a special filter which allows filter functions to be controlled by VScript. See VScript in Mapbase for more information on VScript.
Here's a list of the hooks filter_script can use:
SignatureDescription
bool PassesFilter(handle caller, handle entity)Check if the given caller and entity pass the filter.
bool PassesDamageFilter(handle caller, handle info)Check if the given caller and damage info pass the damage filter.
bool PassesFinalDamageFilter(handle caller, handle info)Used by filter_damage_redirect to distinguish between standalone filter calls and actually damaging an entity. Returns true if there's no unique behavior.
bool BloodAllowed(handle caller, handle info)Check if the given caller and damage info allow for the production of blood.
bool DamageMod(handle caller, handle info)Mods the damage info with the given caller.
  • 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('^' + ".*" + '

Skip to content
Filters
Jump to bottom

Blixibon edited this page Jun 27, 2020
·
9 revisions
A filter tests a certain condition or set of conditions to filter through entities, like a trigger_once using a filter_activator_name that only allows an entity with the name "cow" to pass it. Click here for more information on filters in Source.
In Mapbase, all filters have been given the following new I/O/KV:
Inputs
  • TestEntity<ehandle> - Tests the filter against the specified entity and fires OnPass or OnFail based on the result. (TestActivator only uses the activator)
  • SetField<any> - Sets this filter's primary testing criteria (e.g. the name to test against the activator).
KeyValues
  • Pass caller when tested<boolean> - When tested with TestActivator or TestEntity, this causes the OnPass and OnFail outputs to use the entity that called the test as the caller instead of the filter itself.
New filters
Mapbase adds a few new filters so mappers could test more conditions:
NameDescription
filter_activator_modelFilters an entity by its model's name. This entity already exists in all games starting with Left 4 Dead, but Mapbase adds the option to filter by skin and supports matchers.
filter_activator_contextFilters an entity by its response contexts. This entity already exists in all games starting with Left 4 Dead, but Mapbase allows for multiple contexts to be used at once and supports matchers.
filter_activator_squadFilters an NPC by its squad name, with the option to deny silent members. (enemy finders, vital allies in player_squad, etc.)
filter_activator_hintgroupFilters an NPC by its hint group, with the option to filter Hint Limit Nav.
filter_activator_keyfieldFilters an entity by its keyvalues, serving as an extension of logic_keyfield.
filter_activator_relationshipFilters an entity by its relationship to a target, or vice versa.
filter_activator_classifyFilters an entity by its Classify() class. (e.g. CLASS_PLAYER_ALLY)
filter_activator_criteriaFilters an entity by response criteria normally used in the response system.
filter_activator_involumeFilters an entity by whether it's inside of a target entity's volume. (e.g. a trigger)
filter_activator_surfacedataFilters an entity by its surface data. (e.g. whether it's made of wood)
Redirect filters
Redirect filters are a new "class" of filters that take a separate entity from the activator and pass it to another filter. For example, a trigger_once using a filter_redirect_weapon gets the activator's weapon and passes it to a filter_activator_class, which checks if it's a weapon_pistol.
Here's a list of the redirect filters introduced in Mapbase:
NameDescription
filter_redirect_weaponRedirects the activator's weapon. When used as a damage filter, this gets the weapon used in the damage.
filter_redirect_ownerRedirects the activator's owner entity.
filter_redirect_inflictorAs a damage filter, this redirects the inflictor of the damage, e.g. the grenade in an explosion. (filters normally use the attacker)
Damage manipulators
Damage manipulators are a family of filters designed to be used as damage filters, directly manipulating or operating with damage in some way. They don't actually filter anything themselves, but they can use a "secondary filter" to act as an actual damage filter or to control their behavior.
4 of these entities exist in Mapbase:
NameDescription
filter_damage_transferCauses damage taken by entities using this filter to transfer to a different entity, or a set of entities.
filter_damage_modModifies damage taken by entities using this filter.
filter_damage_logicFires outputs with damage parameters whenever an entity using this filter takes damage.
filter_blood_controlControls whether blood can be emitted when an entity using this filter takes damage. (does not affect actual damage on its own)
filter_script
filter_script is a special filter which allows filter functions to be controlled by VScript. See VScript in Mapbase for more information on VScript.
Here's a list of the hooks filter_script can use:
SignatureDescription
bool PassesFilter(handle caller, handle entity)Check if the given caller and entity pass the filter.
bool PassesDamageFilter(handle caller, handle info)Check if the given caller and damage info pass the damage filter.
bool PassesFinalDamageFilter(handle caller, handle info)Used by filter_damage_redirect to distinguish between standalone filter calls and actually damaging an entity. Returns true if there's no unique behavior.
bool BloodAllowed(handle caller, handle info)Check if the given caller and damage info allow for the production of blood.
bool DamageMod(handle caller, handle info)Mods the damage info with the given caller.
  • 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" + '

Skip to content
Filters
Jump to bottom

Blixibon edited this page Jun 27, 2020
·
9 revisions
A filter tests a certain condition or set of conditions to filter through entities, like a trigger_once using a filter_activator_name that only allows an entity with the name "cow" to pass it. Click here for more information on filters in Source.
In Mapbase, all filters have been given the following new I/O/KV:
Inputs
  • TestEntity<ehandle> - Tests the filter against the specified entity and fires OnPass or OnFail based on the result. (TestActivator only uses the activator)
  • SetField<any> - Sets this filter's primary testing criteria (e.g. the name to test against the activator).
KeyValues
  • Pass caller when tested<boolean> - When tested with TestActivator or TestEntity, this causes the OnPass and OnFail outputs to use the entity that called the test as the caller instead of the filter itself.
New filters
Mapbase adds a few new filters so mappers could test more conditions:
NameDescription
filter_activator_modelFilters an entity by its model's name. This entity already exists in all games starting with Left 4 Dead, but Mapbase adds the option to filter by skin and supports matchers.
filter_activator_contextFilters an entity by its response contexts. This entity already exists in all games starting with Left 4 Dead, but Mapbase allows for multiple contexts to be used at once and supports matchers.
filter_activator_squadFilters an NPC by its squad name, with the option to deny silent members. (enemy finders, vital allies in player_squad, etc.)
filter_activator_hintgroupFilters an NPC by its hint group, with the option to filter Hint Limit Nav.
filter_activator_keyfieldFilters an entity by its keyvalues, serving as an extension of logic_keyfield.
filter_activator_relationshipFilters an entity by its relationship to a target, or vice versa.
filter_activator_classifyFilters an entity by its Classify() class. (e.g. CLASS_PLAYER_ALLY)
filter_activator_criteriaFilters an entity by response criteria normally used in the response system.
filter_activator_involumeFilters an entity by whether it's inside of a target entity's volume. (e.g. a trigger)
filter_activator_surfacedataFilters an entity by its surface data. (e.g. whether it's made of wood)
Redirect filters
Redirect filters are a new "class" of filters that take a separate entity from the activator and pass it to another filter. For example, a trigger_once using a filter_redirect_weapon gets the activator's weapon and passes it to a filter_activator_class, which checks if it's a weapon_pistol.
Here's a list of the redirect filters introduced in Mapbase:
NameDescription
filter_redirect_weaponRedirects the activator's weapon. When used as a damage filter, this gets the weapon used in the damage.
filter_redirect_ownerRedirects the activator's owner entity.
filter_redirect_inflictorAs a damage filter, this redirects the inflictor of the damage, e.g. the grenade in an explosion. (filters normally use the attacker)
Damage manipulators
Damage manipulators are a family of filters designed to be used as damage filters, directly manipulating or operating with damage in some way. They don't actually filter anything themselves, but they can use a "secondary filter" to act as an actual damage filter or to control their behavior.
4 of these entities exist in Mapbase:
NameDescription
filter_damage_transferCauses damage taken by entities using this filter to transfer to a different entity, or a set of entities.
filter_damage_modModifies damage taken by entities using this filter.
filter_damage_logicFires outputs with damage parameters whenever an entity using this filter takes damage.
filter_blood_controlControls whether blood can be emitted when an entity using this filter takes damage. (does not affect actual damage on its own)
filter_script
filter_script is a special filter which allows filter functions to be controlled by VScript. See VScript in Mapbase for more information on VScript.
Here's a list of the hooks filter_script can use:
SignatureDescription
bool PassesFilter(handle caller, handle entity)Check if the given caller and entity pass the filter.
bool PassesDamageFilter(handle caller, handle info)Check if the given caller and damage info pass the damage filter.
bool PassesFinalDamageFilter(handle caller, handle info)Used by filter_damage_redirect to distinguish between standalone filter calls and actually damaging an entity. Returns true if there's no unique behavior.
bool BloodAllowed(handle caller, handle info)Check if the given caller and damage info allow for the production of blood.
bool DamageMod(handle caller, handle info)Mods the damage info with the given caller.
  • 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('^' + ".*" + '

Skip to content
Filters
Jump to bottom

Blixibon edited this page Jun 27, 2020
·
9 revisions
A filter tests a certain condition or set of conditions to filter through entities, like a trigger_once using a filter_activator_name that only allows an entity with the name "cow" to pass it. Click here for more information on filters in Source.
In Mapbase, all filters have been given the following new I/O/KV:
Inputs
  • TestEntity<ehandle> - Tests the filter against the specified entity and fires OnPass or OnFail based on the result. (TestActivator only uses the activator)
  • SetField<any> - Sets this filter's primary testing criteria (e.g. the name to test against the activator).
KeyValues
  • Pass caller when tested<boolean> - When tested with TestActivator or TestEntity, this causes the OnPass and OnFail outputs to use the entity that called the test as the caller instead of the filter itself.
New filters
Mapbase adds a few new filters so mappers could test more conditions:
NameDescription
filter_activator_modelFilters an entity by its model's name. This entity already exists in all games starting with Left 4 Dead, but Mapbase adds the option to filter by skin and supports matchers.
filter_activator_contextFilters an entity by its response contexts. This entity already exists in all games starting with Left 4 Dead, but Mapbase allows for multiple contexts to be used at once and supports matchers.
filter_activator_squadFilters an NPC by its squad name, with the option to deny silent members. (enemy finders, vital allies in player_squad, etc.)
filter_activator_hintgroupFilters an NPC by its hint group, with the option to filter Hint Limit Nav.
filter_activator_keyfieldFilters an entity by its keyvalues, serving as an extension of logic_keyfield.
filter_activator_relationshipFilters an entity by its relationship to a target, or vice versa.
filter_activator_classifyFilters an entity by its Classify() class. (e.g. CLASS_PLAYER_ALLY)
filter_activator_criteriaFilters an entity by response criteria normally used in the response system.
filter_activator_involumeFilters an entity by whether it's inside of a target entity's volume. (e.g. a trigger)
filter_activator_surfacedataFilters an entity by its surface data. (e.g. whether it's made of wood)
Redirect filters
Redirect filters are a new "class" of filters that take a separate entity from the activator and pass it to another filter. For example, a trigger_once using a filter_redirect_weapon gets the activator's weapon and passes it to a filter_activator_class, which checks if it's a weapon_pistol.
Here's a list of the redirect filters introduced in Mapbase:
NameDescription
filter_redirect_weaponRedirects the activator's weapon. When used as a damage filter, this gets the weapon used in the damage.
filter_redirect_ownerRedirects the activator's owner entity.
filter_redirect_inflictorAs a damage filter, this redirects the inflictor of the damage, e.g. the grenade in an explosion. (filters normally use the attacker)
Damage manipulators
Damage manipulators are a family of filters designed to be used as damage filters, directly manipulating or operating with damage in some way. They don't actually filter anything themselves, but they can use a "secondary filter" to act as an actual damage filter or to control their behavior.
4 of these entities exist in Mapbase:
NameDescription
filter_damage_transferCauses damage taken by entities using this filter to transfer to a different entity, or a set of entities.
filter_damage_modModifies damage taken by entities using this filter.
filter_damage_logicFires outputs with damage parameters whenever an entity using this filter takes damage.
filter_blood_controlControls whether blood can be emitted when an entity using this filter takes damage. (does not affect actual damage on its own)
filter_script
filter_script is a special filter which allows filter functions to be controlled by VScript. See VScript in Mapbase for more information on VScript.
Here's a list of the hooks filter_script can use:
SignatureDescription
bool PassesFilter(handle caller, handle entity)Check if the given caller and entity pass the filter.
bool PassesDamageFilter(handle caller, handle info)Check if the given caller and damage info pass the damage filter.
bool PassesFinalDamageFilter(handle caller, handle info)Used by filter_damage_redirect to distinguish between standalone filter calls and actually damaging an entity. Returns true if there's no unique behavior.
bool BloodAllowed(handle caller, handle info)Check if the given caller and damage info allow for the production of blood.
bool DamageMod(handle caller, handle info)Mods the damage info with the given caller.
  • 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('^' + ".*" + '

Skip to content
Filters
Jump to bottom

Blixibon edited this page Jun 27, 2020
·
9 revisions
A filter tests a certain condition or set of conditions to filter through entities, like a trigger_once using a filter_activator_name that only allows an entity with the name "cow" to pass it. Click here for more information on filters in Source.
In Mapbase, all filters have been given the following new I/O/KV:
Inputs
  • TestEntity<ehandle> - Tests the filter against the specified entity and fires OnPass or OnFail based on the result. (TestActivator only uses the activator)
  • SetField<any> - Sets this filter's primary testing criteria (e.g. the name to test against the activator).
KeyValues
  • Pass caller when tested<boolean> - When tested with TestActivator or TestEntity, this causes the OnPass and OnFail outputs to use the entity that called the test as the caller instead of the filter itself.
New filters
Mapbase adds a few new filters so mappers could test more conditions:
NameDescription
filter_activator_modelFilters an entity by its model's name. This entity already exists in all games starting with Left 4 Dead, but Mapbase adds the option to filter by skin and supports matchers.
filter_activator_contextFilters an entity by its response contexts. This entity already exists in all games starting with Left 4 Dead, but Mapbase allows for multiple contexts to be used at once and supports matchers.
filter_activator_squadFilters an NPC by its squad name, with the option to deny silent members. (enemy finders, vital allies in player_squad, etc.)
filter_activator_hintgroupFilters an NPC by its hint group, with the option to filter Hint Limit Nav.
filter_activator_keyfieldFilters an entity by its keyvalues, serving as an extension of logic_keyfield.
filter_activator_relationshipFilters an entity by its relationship to a target, or vice versa.
filter_activator_classifyFilters an entity by its Classify() class. (e.g. CLASS_PLAYER_ALLY)
filter_activator_criteriaFilters an entity by response criteria normally used in the response system.
filter_activator_involumeFilters an entity by whether it's inside of a target entity's volume. (e.g. a trigger)
filter_activator_surfacedataFilters an entity by its surface data. (e.g. whether it's made of wood)
Redirect filters
Redirect filters are a new "class" of filters that take a separate entity from the activator and pass it to another filter. For example, a trigger_once using a filter_redirect_weapon gets the activator's weapon and passes it to a filter_activator_class, which checks if it's a weapon_pistol.
Here's a list of the redirect filters introduced in Mapbase:
NameDescription
filter_redirect_weaponRedirects the activator's weapon. When used as a damage filter, this gets the weapon used in the damage.
filter_redirect_ownerRedirects the activator's owner entity.
filter_redirect_inflictorAs a damage filter, this redirects the inflictor of the damage, e.g. the grenade in an explosion. (filters normally use the attacker)
Damage manipulators
Damage manipulators are a family of filters designed to be used as damage filters, directly manipulating or operating with damage in some way. They don't actually filter anything themselves, but they can use a "secondary filter" to act as an actual damage filter or to control their behavior.
4 of these entities exist in Mapbase:
NameDescription
filter_damage_transferCauses damage taken by entities using this filter to transfer to a different entity, or a set of entities.
filter_damage_modModifies damage taken by entities using this filter.
filter_damage_logicFires outputs with damage parameters whenever an entity using this filter takes damage.
filter_blood_controlControls whether blood can be emitted when an entity using this filter takes damage. (does not affect actual damage on its own)
filter_script
filter_script is a special filter which allows filter functions to be controlled by VScript. See VScript in Mapbase for more information on VScript.
Here's a list of the hooks filter_script can use:
SignatureDescription
bool PassesFilter(handle caller, handle entity)Check if the given caller and entity pass the filter.
bool PassesDamageFilter(handle caller, handle info)Check if the given caller and damage info pass the damage filter.
bool PassesFinalDamageFilter(handle caller, handle info)Used by filter_damage_redirect to distinguish between standalone filter calls and actually damaging an entity. Returns true if there's no unique behavior.
bool BloodAllowed(handle caller, handle info)Check if the given caller and damage info allow for the production of blood.
bool DamageMod(handle caller, handle info)Mods the damage info with the given caller.
  • 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); }
})();
})();

Skip to content
Filters
Jump to bottom

Blixibon edited this page Jun 27, 2020
·
9 revisions
A filter tests a certain condition or set of conditions to filter through entities, like a trigger_once using a filter_activator_name that only allows an entity with the name "cow" to pass it. Click here for more information on filters in Source.
In Mapbase, all filters have been given the following new I/O/KV:
Inputs
  • TestEntity<ehandle> - Tests the filter against the specified entity and fires OnPass or OnFail based on the result. (TestActivator only uses the activator)
  • SetField<any> - Sets this filter's primary testing criteria (e.g. the name to test against the activator).
KeyValues
  • Pass caller when tested<boolean> - When tested with TestActivator or TestEntity, this causes the OnPass and OnFail outputs to use the entity that called the test as the caller instead of the filter itself.
New filters
Mapbase adds a few new filters so mappers could test more conditions:
NameDescription
filter_activator_modelFilters an entity by its model's name. This entity already exists in all games starting with Left 4 Dead, but Mapbase adds the option to filter by skin and supports matchers.
filter_activator_contextFilters an entity by its response contexts. This entity already exists in all games starting with Left 4 Dead, but Mapbase allows for multiple contexts to be used at once and supports matchers.
filter_activator_squadFilters an NPC by its squad name, with the option to deny silent members. (enemy finders, vital allies in player_squad, etc.)
filter_activator_hintgroupFilters an NPC by its hint group, with the option to filter Hint Limit Nav.
filter_activator_keyfieldFilters an entity by its keyvalues, serving as an extension of logic_keyfield.
filter_activator_relationshipFilters an entity by its relationship to a target, or vice versa.
filter_activator_classifyFilters an entity by its Classify() class. (e.g. CLASS_PLAYER_ALLY)
filter_activator_criteriaFilters an entity by response criteria normally used in the response system.
filter_activator_involumeFilters an entity by whether it's inside of a target entity's volume. (e.g. a trigger)
filter_activator_surfacedataFilters an entity by its surface data. (e.g. whether it's made of wood)
Redirect filters
Redirect filters are a new "class" of filters that take a separate entity from the activator and pass it to another filter. For example, a trigger_once using a filter_redirect_weapon gets the activator's weapon and passes it to a filter_activator_class, which checks if it's a weapon_pistol.
Here's a list of the redirect filters introduced in Mapbase:
NameDescription
filter_redirect_weaponRedirects the activator's weapon. When used as a damage filter, this gets the weapon used in the damage.
filter_redirect_ownerRedirects the activator's owner entity.
filter_redirect_inflictorAs a damage filter, this redirects the inflictor of the damage, e.g. the grenade in an explosion. (filters normally use the attacker)
Damage manipulators
Damage manipulators are a family of filters designed to be used as damage filters, directly manipulating or operating with damage in some way. They don't actually filter anything themselves, but they can use a "secondary filter" to act as an actual damage filter or to control their behavior.
4 of these entities exist in Mapbase:
NameDescription
filter_damage_transferCauses damage taken by entities using this filter to transfer to a different entity, or a set of entities.
filter_damage_modModifies damage taken by entities using this filter.
filter_damage_logicFires outputs with damage parameters whenever an entity using this filter takes damage.
filter_blood_controlControls whether blood can be emitted when an entity using this filter takes damage. (does not affect actual damage on its own)
filter_script
filter_script is a special filter which allows filter functions to be controlled by VScript. See VScript in Mapbase for more information on VScript.
Here's a list of the hooks filter_script can use:
SignatureDescription
bool PassesFilter(handle caller, handle entity)Check if the given caller and entity pass the filter.
bool PassesDamageFilter(handle caller, handle info)Check if the given caller and damage info pass the damage filter.
bool PassesFinalDamageFilter(handle caller, handle info)Used by filter_damage_redirect to distinguish between standalone filter calls and actually damaging an entity. Returns true if there's no unique behavior.
bool BloodAllowed(handle caller, handle info)Check if the given caller and damage info allow for the production of blood.
bool DamageMod(handle caller, handle info)Mods the damage info with the given caller.
  • Something Index
    • Something special
    • Something else
Clone this wiki locally