Source.Python forums

#include <sourcemod>
#include <tf2_stocks>
#include <morecolors>

#pragma semicolon		1
#pragma newdecls		required

#define MXPLYR			MAXPLAYERS+1


int iProPlayer[ MXPLYR ];

public Plugin myinfo =
{
	name = "WepAlphanator",
	author = "Assyrian/Nergal",
	description = "makes weapons transparent",
	version = "1.0",
	url = "http://www.sourcemod.net/"
}

public void OnPluginStart()
{
	RegConsoleCmd("sm_pro",		CommandSetWepAlpha, "Weapon Alpha");
	RegConsoleCmd("sm_angles",	CommandInfo, "Weapon Angles");
	RegAdminCmd("sm_adpro",		CommandSetAdminWepAlpha, ADMFLAG_SLAY, "Admin Weapon Alpha");

	HookEvent("player_spawn", Eventery);
	HookEvent("post_inventory_application", Eventery);

	for (int i = 1; i <= MaxClients; i++)
	{
		if ( !IsValidClient(i) ) continue;
		OnClientPutInServer(i);
	}
}
public void OnClientPutInServer( int client )
{
	iProPlayer[client] = -1;
}

public Action CommandInfo(int client, int args)
{
	float flVector[3]; GetClientEyeAngles(client, flVector);
	CPrintToChat(client, "{green}Your Eye Angles: x:%f, y:%f, z:%f", flVector[0], flVector[1], flVector[2]);

	GetClientEyePosition(client, flVector);
	CPrintToChat(client, "{green}Your Eye Position: x:%f, y:%f, z:%f", flVector[0], flVector[1], flVector[2]);

	GetEntPropVector(client, Prop_Data, "m_vecAbsOrigin", flVector);
	CPrintToChat(client, "{green}Your Absolute Origin from Property Vector: x:%f, y:%f, z:%f", flVector[0], flVector[1], flVector[2]);

	GetEntPropVector(client, Prop_Send, "m_vecMaxs", flVector);
	CPrintToChat(client, "{green}Your Vector Max Size: x:%f, y:%f, z:%f", flVector[0], flVector[1], flVector[2]);

	GetEntPropVector(client, Prop_Send, "m_vecMins", flVector);
	CPrintToChat(client, "{green}Your Vector Min Size: x:%f, y:%f, z:%f", flVector[0], flVector[1], flVector[2]);

	GetEntPropVector(client, Prop_Data, "m_angAbsRotation", flVector);
	CPrintToChat(client, "{green}Your Absolute Angle Rotation: x:%f, y:%f, z:%f", flVector[0], flVector[1], flVector[2]);

	GetEntPropVector(client, Prop_Data, "m_vecVelocity", flVector);
	CPrintToChat(client, "{green}Your Velocity: x:%f, y:%f, z:%f", flVector[0], flVector[1], flVector[2]);

	return Plugin_Continue;
}
public Action CommandSetWepAlpha(int client, int args)
{
	if (args < 1)
	{
		ReplyToCommand(client, "[Alpha Weps] Usage: !pro <0-255>");
		return Plugin_Handled;
	}
	char number[8]; GetCmdArg(1, number, sizeof(number));

	int maxalpha = StringToInt(number);
	iProPlayer[client] = maxalpha;
	SetWeaponInvis(client, maxalpha);
	CPrintToChat(client, "{green}You've Turned Your Weapon Transparent!");

	return Plugin_Continue;
}
public Action CommandSetAdminWepAlpha(int client, int args)
{
	if (args < 2)
	{
		ReplyToCommand(client, "[Alpha Weps] Usage: !adpro <target> <0-255>");
		return Plugin_Handled;
	}
	char szTargetname[64]; GetCmdArg(1, szTargetname, sizeof(szTargetname));
	char szNum[64]; GetCmdArg(2, szNum, sizeof(szNum));

	int maxalpha = StringToInt(szNum);

	char target_name[MAX_TARGET_LENGTH];
	int target_list[MAXPLAYERS+1], target_count;
	bool tn_is_ml;
	if ( (target_count = ProcessTargetString(szTargetname, client, target_list, MAXPLAYERS, COMMAND_FILTER_ALIVE, target_name, sizeof(target_name), tn_is_ml)) <= 0 )
	{
		ReplyToTargetError(client, target_count);
		return Plugin_Handled;
	}
	for (int i = 0; i < target_count; i++)
	{
		if ( IsValidClient(target_list[i]) && IsPlayerAlive(target_list[i]) )
		{
			SetWeaponInvis(target_list[i], maxalpha);
			CPrintToChat(target_list[i], "{unusual}Your Weapon Is Transparent!");
		}
	}
	return Plugin_Handled;
}
public Action Eventery(Event event, const char[] name, bool dontBroadcast)
{
	int i = GetClientOfUserId( event.GetInt("userid") );
	if ( IsValidClient(i) )
	{
		if ( iProPlayer[i] != -1 ) SetWeaponInvis( i, iProPlayer[i] );
	}
	return Plugin_Continue;
}
stock void SetWeaponInvis(int client, int &alpha)
{
	for (int i = 0; i < 5; i++)
	{
		int entity = GetPlayerWeaponSlot(client, i); 
		if ( IsValidEdict(entity) && IsValidEntity(entity) )
		{
			if (alpha < 0) alpha = 0;
			else if (alpha > 255) alpha = 255;
			SetEntityRenderMode(entity, RENDER_TRANSCOLOR); 
			SetEntityRenderColor(entity, 150, 150, 150, alpha); 
		}
	}
	return;
}
stock bool IsValidClient(int client, bool replaycheck = true)
{
	if ( client <= 0 || client > MaxClients) return false;
	if ( !IsClientInGame(client) ) return false;
	if ( GetEntProp(client, Prop_Send, "m_bIsCoaching") ) return false;
	if ( replaycheck ) if ( IsClientSourceTV(client) || IsClientReplay(client) ) return false;
	return true;
}

# Python Imports
#from collections import defaultdict

# SourcePython imports
from players.entity import PlayerEntity

from players.helpers import userid_from_index
from players.helpers import index_from_userid

from weapons.entity import WeaponEntity

from entities.constants import RenderMode

from events import Event
from colors import Color

from commands.say import SayCommand

from cvars.public import PublicConVar
from plugins.info import PluginInfo

info = PluginInfo()
info.name = "AlphaWeps"
info.author = "Nergal/Assyrian"
info.version = "1.0"
info.basename = "alphaweps"
info.variable = info.basename + "_version"
info.convar = PublicConVar(info.variable, info.version, 0, info.name + " Version")

#create a list
iProPlayer = [i+1 for i in range(66)]

@SayCommand('!pro')
def pro_command(index, teamonly, CCommand):
	text = CCommand[1].split()
	if len(text) < 0:
		return True

	iProPlayer[index] = int(text)
	set_weapon_invis(userid_from_index(index), iProPlayer[index])

@Event
def player_connect(game_event):
	userid = game_event.get_int('userid')
	set_playerlist(userid)

@Event
def player_disconnect(game_event):
	userid = game_event.get_int('userid')
	set_playerlist(userid)

@Event
def player_spawn(game_event):
	eventery(game_event.get_int('userid'))

@Event
def post_inventory_application(game_event):
	eventery(game_event.get_int('userid'))

def eventery(userid):
	index = index_from_userid(userid)
	if iProPlayer[index] is not None:
		set_weapon_invis(userid, iProPlayer[userid])

def set_playerlist(userid):
	index = index_from_userid(userid)
	iProPlayer[index] = None

def set_weapon_invis(userid, alpha):
	try:
		index = index_of_userid(userid)
	except ValueError:
		print('Wrong userid: ', userid)

	player = PlayerEntity(index)
	alpha = max(min(alpha, 255), 0)

	for weapon_index in player.weapon_indexes():
		entity = WeaponEntity(weapon_index)
		entity.render_mode = RenderMode.TRANS_COLOR
		entity.color = Color(150, 150, 150, alpha)

#def is_client_valid(userid)
#    index = index_from_userid(userid) 
#    if index < 0 or index >

# .. in some function providing a userid:
    try:
        index = index_of_userid(userid)
    except ValueError:
        print('Wrong userid: ', userid)

# Python Imports
from collections import defaultdict

# SourcePython imports
from players.helpers import userid_from_index, index_from_userid, index_from_playerinfo, userid_from_playerinfo

from players._base import Player

from entities.constants import RenderMode
from events import Event

from weapons.entity import Weapon

from commands.say import SayCommand

from cvars.public import PublicConVar
from plugins.info import PluginInfo


info = PluginInfo()
info.name = "AlphaWeps"
info.author = "Nergal/Assyrian"
info.version = "1.0"
info.basename = "alphaweps"
info.variable = info.basename + "_version"
info.convar = PublicConVar(info.variable, info.version, info.name + " Version", 0)

#create a dictionary
dict_wep_invis_player = defaultdict(lambda: None) #dict(i+1 for i in range(65))

def load():
	print("alphaweps is loaded!")

def unload():
	print("alphaweps is unloaded!")


from commands.typed import TypedSayCommand
@TypedSayCommand('!pro')
def on_wepinvis_pro(command_info, x:int):	# command_info.index is the only player info available
	player_userid = userid_from_index(command_info.index)
	set_weapon_invis(player_userid, x)

@TypedSayCommand('!vm')
def on_wepinvis_vm(command_info, x:int):
	player_userid = userid_from_index(command_info.index)
	set_weapon_invis(player_userid, x)

@Event('player_disconnect')
def on_player_disconnect(game_event):
	if index in dict_wep_invis_player:
		del dict_wep_invis_player[str(game_event['userid'])]

@Event('player_spawn')
def on_player_spawn(game_event):
	make_weps_invis(game_event['userid'])

@Event('post_inventory_application')
def on_resupply(game_event):
	make_weps_invis(game_event['userid'])

def make_weps_invis(userid):
	if dict_wep_invis_player[str(userid)] is not None:
		set_weapon_invis(userid, dict_wep_invis_player[str(userid)])

def set_weapon_invis(userid, ialpha):
	player = Player.from_userid(userid)
	ialpha = max( min(ialpha, 255), 0 )
	print("set_weapon_invis called!")
	dict_wep_invis_player[str(userid)] = ialpha
	#print(dict_wep_invis_player[str(userid)])
	#print(userid)
	for weapon in player.weapon_indexes():
		#wep = Weapon(weapon)
		#wep.render_mode = RenderMode.TRANS_COLOR
		Weapon(weapon).set_color(Color(255, 255, 255, ialpha))

# SourcePython imports
from commands.typed import TypedSayCommand
from core import echo_console
from cvars.public import PublicConVar
from events import Event
from listeners import LevelInit
from players.entity import Player
from plugins.info import PluginInfo


info = PluginInfo()
info.name = "AlphaWeps"
info.author = "Nergal/Assyrian"
info.version = "1.0"
info.basename = "alphaweps"
info.variable = info.basename + "_version"
info.convar = PublicConVar(info.variable, info.version, info.name + " Version", 0)


player_dict = {}


def load():
    echo_console("alphaweps is loaded!")


def unload():
    echo_console("alphaweps is unloaded!")


@TypedSayCommand('!pro')
def pro_command(command_info, x:int):
    player = Player(command_info.index)
    alpha = player_dict[player.userid] = max(min(x, 255), 0)
    set_weapon_visibility(player.userid)


@TypedSayCommand('!vm')
def on_wepinvis_vm(command_info, x:int):
    player = Player(command_info.index)
    alpha = player_dict[player.userid] = max(min(x, 255), 0)
    set_weapon_visibility(player.userid)


@Event('player_disconnect')
def on_player_disconnect(game_event):
    userid = game_event['userid']
    if userid in dict_wep_invis_player:
        del dict_wep_invis_player[userid]


@Event('post_inventory_application', 'player_spawn')
def on_resupply(game_event):
    echo_console(game_event.name)
    set_weapon_visibility(game_event['userid'])


@LevelInit
def level_init(mapname):
    player_dict.clear()


def set_weapon_visibility(userid):
    alpha = player_dict.get(userid)
    if alpha is None:
        return

    player = Player.from_userid(userid)
    for weapon in player.weapons():
        weapon.color = weapon.color.with_alpha(alpha)

struct keyval {
	const char *key;
	void *val;
	struct keyval *next;
};

struct dict {
	unsigned int size;		/* size of the pointer table */
	unsigned int count;		/* number of elements stored */
	struct keyval **table;		/* dictionaries are practically vectors of linked lists */
};

unsigned long gethash(const char *szKey)
{
	unsigned const char *us;
	unsigned long h = 0;
	for (us = (unsigned const char *)szKey ; *us ; us++)
		h = h * 97 + *us;
	return h;
}