[Outdated] MAT Automation Unblock Script - Page 2 - MPGH

How to do this ??

---------- Post added at 12:11 AM ---------- Previous post was at 12:10 AM ----------

it still work and how to use this script teach me pls with video or anything

---------- Post added at 12:53 AM ---------- Previous post was at 12:11 AM ----------

tolong aq weh camne nk buat

ok video upload

. Luqman Hakimi
aku akan upload nnti video kt youtube

How to Make Script

Originally Posted by pc117

My Unblock scrpits

want to make themselves understood

#
# Simple example which uses a pool of workers to carry out some tasks.
#
# Notice that the results will probably not come out of the output
# queue in the same in the same order as the corresponding tasks were
# put on the input queue. If it is important to get the results back
# in the original order then consider using `Pool.map()` or
# `Pool.imap()` (which will save on the amount of code needed anyway).
#
# Copyright (c) 2006-2008, R Oudkerk
# All rights reserved.
#

import time
import random

from multiprocessing import Process, Queue, current_process, freeze_support

#
# Function run by worker processes
#

def worker(input, output):
for func, args in iter(input.get, 'STOP'):
result = calculate(func, args)
output.put(result)

#
# Function used to calculate result
#

def calculate(func, args):
result = func(*args)
return '%s says that %s%s = %s' % \
(current_process().name, func.__name__, args, result)

#
# Functions referenced by tasks
#

def mul(a, b):
time.sleep(0.5*random.random())
return a * b

def plus(a, b):
time.sleep(0.5*random.random())
return a + b

#
#
#

def test():
NUMBER_OF_PROCESSES = 4
TASKS1 = [(mul, (i, 7)) for i in range(20)]
TASKS2 = [(plus, (i, 8)) for i in range(10)]

# Create queues
task_queue = Queue()
done_queue = Queue()

# Submit tasks
for task in TASKS1:
task_queue.put(task)

# Start worker processes
for i in range(NUMBER_OF_PROCESSES):
Process(target=worker, args=(task_queue, done_queue)).start()

# Get and print results
print('Unordered results:')
for i in range(len(TASKS1)):
print('\t', done_queue.get())

# Add more tasks using `put()`
for task in TASKS2:
task_queue.put(task)

# Get and print some more results
for i in range(len(TASKS2)):
print('\t', done_queue.get())

# Tell child processes to stop
for i in range(NUMBER_OF_PROCESSES):
task_queue.put('STOP')

if __name__ == '__main__':
freeze_support()
test()

Can give TUT

#
# Project: Mat Narco
#
# Aiming & utilities
# - Copyright (C) 2010 dB. All rights reserved.
#

# Python imports
import os
import json

# Narco imports
from Automaton.System import Register
from Automaton.Outputs import Logger
from Automaton import AntTweakBar
from Automaton import Keys

# Unreal imports
from Unreal.Core import Vector, Rotator, Color
from Unreal.Core import Object as ObjectClass
from Unreal.Engine import Actor as ActorClass
from Unreal.Engine import Pawn as PawnClass
from Unreal.Engine import Texture as TextureClass
from Unreal.Engine import Weapon as WeaponClass

# Fetch important functions
DynamicLoadObject = FindFunction ( ObjectClass, 'DynamicLoadObject' )

# Physics constants
(PHYS_None, PHYS_Walking,
PHYS_Falling, PHYS_Swimming,
PHYS_Flying, PHYS_Rotating,
PHYS_Projectile, PHYS_Interpolating,
PHYS_MovingBrush, PHYS_Spider,
PHYS_Trailer, PHYS_Ladder,
PHYS_RootMotion, PHYS_Karma,
PHYS_KarmaRagDoll, PHYS_Hovering) = range ( 16 )

# Pawn bit constants
(EPB_UseItem, EPB_God,
EPB_Dance, EPB_Speedup,
EPB_AutoAim, EPB_Mini,
EPB_Talking, EPB_7,
EPB_FilterBadState, EPB_Hide,
EPB_Second, EPB_Third,
EPB_12, EPB_13,
EPB_14, EPB_15,
EPB_MagicChange, EPB_Frozen,
EPB_Chaos, EPB_Speeddown,
EPB_LightingStrike, EPB_Vertigo,
EPB_CorpseChange, EPB_EvilPigChange,
EPB_Terminator, EPB_25,
EPB_26, EPB_27,
EPB_28, EPB_29,
EPB_30, EPB_Max) = range ( 32 )

# Bone constants
(BONE_Head, BONE_Root) = range ( 2 )

# Team constants
(TEAM_Blue, TEAM_Red) = range ( 2 )

# Aiming modes
(AIMING_Health, AIMING_Distance, AIMING_Key) = range ( 3 )

class Aiming(object):
def __init__(self):
# Defaults
self.Wireframe = False
self.Wallhack = False
self.AlwaysDraw = False
self.AutoAim = False
self.AutoFire = False
self.FriendlyFire = False
self.LatencyCorrection = False
self.SecondaryFire = False
self.AimKey = Keys.Shift
self.AimMode = AIMING_Health
self.BonePrecedence = BONE_Head
# Initialization
self.KeyDown = False
self.Viewport = None
self.WhiteTexture = None
self.AimingModes = {
AIMING_Health : self.__best_byhealth,
AIMING_Distance : self.__best_bydistance,
AIMING_Key : self.__best_bykey
}

# Aiming mode comperators
def __best_byhealth(self, current, other):
return other.Health < current.Health
def __best_bydistance(self, current, other):
CameraLocation = self.Viewport.Actor.CalcViewLocation
CurrentDistance = abs ( current.Location - CameraLocation )
OtherDistance = abs ( other.Location - CameraLocation )
return OtherDistance < CurrentDistance
def __best_bykey(self, current, other):
CameraLocation = self.Viewport.Actor.CalcViewLocation
CameraRotation = self.Viewport.Actor.CalcViewRotation
desired = CameraRotation.Vector ()
dotCurrent = desired | ( current.Location - CameraLocation ).Normal ()
dotOther = desired | ( other.Location - CameraLocation ).Normal ()
return dotOther > dotCurrent

# Compare two pawns
def Compare(self, pawn, other):
return self.AimingModes [ self.AimMode ] ( pawn, other )

def Tick(self, deltatime):
if ( self.Viewport and self.Viewport.Actor ):
# Get our player controller
PC = self.Viewport.Actor

# Fetch camera information
CameraLocation = PC.CalcViewLocation
CameraRotation = PC.CalcViewRotation

# Setup configuration data
FireMode = int ( self.SecondaryFire )
AutoAim = self.AutoAim and ( self.AimMode != AIMING_Key or self.KeyDown )

# If we are auto aiming
if ( AutoAim and PC.Pawn ):
# Look for the best target
BestPawn = None
BestLocation = None
for Pawn in PC.DynamicActors ( PawnClass, PC ):
# Check if the pawn is valid
if ( not self.Valid ( Pawn ) or Pawn == PC.Pawn or not self.Damagable ( Pawn ) ): continue

# If it is a team game make sure we are on a different team
if ( not self.FriendlyFire and self.SameTeam ( Pawn ) ): continue

# Setup bones list
BoneList = ( self.BonePrecedence == BONE_Root ) \
and [Pawn****otBone, Pawn.HeadBone] \
or [Pawn.HeadBone, Pawn****otBone]

# Find a visible bone
for bone in BoneList:
# Fetch the bone coords
BoneCoords = Pawn.GetBoneCoords ( bone )

# Calculate the location
BoneLocation = BoneCoords.Origin + BoneCoords.XAxis + BoneCoords.YAxis + BoneCoords.ZAxis

# Conditionally apply latency correction
if ( self.LatencyCorrection ):
BoneLocation += self.Correction ( PC, Pawn, deltatime )

# Adjust according to projectile physics
if ( PC.Pawn.Weapon and PC.Pawn.Weapon.FireMode [ FireMode ] and PC.Pawn.Weapon.FireMode [ FireMode ].ProjectileClass ):
Projectile = PC.Pawn.Weapon.FireMode [ FireMode ].ProjectileClass.Default
if ( Projectile and Projectile.Speed != 0 and Projectile.Physics != PHYS_Falling ):
BoneLocation += Pawn.Velocity * ( abs ( BoneLocation - CameraLocation ) / Projectile.Speed )

# Do the check
if ( Pawn.FastTrace ( BoneLocation, CameraLocation ) ):
# Is this the best one?
if ( not BestPawn or self.Compare ( BestPawn, Pawn ) ):
BestPawn = Pawn
BestLocation = BoneLocation
break
if ( BestPawn ):
# We've found a valid target, so lets set the rotation and fire as required
PC.ClientSetRotation ( ( BestLocation - CameraLocation )****tation () )
if ( self.AutoFire and PC.Pawn.Weapon ): PC.Pawn.Weapon.ClientStartFire ( FireMode )

def Render(self, canvas):
if ( self.Viewport and self.Viewport.Actor ):
# Get our player controller and canvs
Canvas = canvas
PC = self.Viewport.Actor

# Fetch game information
TeamGame = PC.GameReplicationInfo and PC.GameReplicationInfo.bTeamGame

# Fetch camera information
CameraLocation = PC.CalcViewLocation
CameraRotation = PC.CalcViewRotation

# Get required textures
self.WhiteTexture = DynamicLoadObject ( 'Engine.WhiteTexture', TextureClass )

# Do our drawing for list of pawns
for Pawn in PC.DynamicActors ( PawnClass, PC ):
# Skip our own pawn and dead pawns
if ( not self.Valid ( Pawn ) or Pawn == PC.Pawn or Pawn.Health <= 0 ): continue

# Deal with wireframe wallhack
if ( self.Wireframe and ( self.AlwaysDraw or self.Invisible ( Pawn ) or not PC.FastTrace ( Pawn.Location, CameraLocation ) ) ):
Canvas.DrawActor ( Pawn, True, True, PC.FovAngle )

# Deal with indicator wallhack
if ( self.Wallhack and self.WhiteTexture ):
HeadCoords = Pawn.GetBoneCoords ( Pawn.HeadBone )

# Raise the indicator above the head
HeadCoords.Origin.Z += 40

# Indicator location
IndicatorLocation = HeadCoords.Origin + HeadCoords.XAxis + HeadCoords.YAxis + HeadCoords.ZAxis

# Get the indicator position on screen
IndicatorPosition = Canvas.WorldToScreen ( IndicatorLocation )

# See if the indicator is within screen area
if ( IndicatorPosition.X >= 0 and IndicatorPosition.X <= Canvas.ClipX and
IndicatorPosition.Y >= 0 and IndicatorPosition.Y <= Canvas.ClipY and
( ( CameraLocation - IndicatorLocation )****tation () - CameraRotation ).Vector ().Normal ().X < 0 ):
# Set default colors
TeamColor = Color ( 0, 0, 255 )
HealthColor = Color ( 0, 255, 0 )

# Set proper team color
if ( TeamGame and Pawn.PlayerReplicationInfo and Pawn.PlayerReplicationInfo.Team ):
colors = {TEAM_Blue: lambda : Color ( 0, 0, 255 ), TEAM_Red: lambda : Color ( 255, 0, 0 )}
TeamColor = colors [ Pawn.PlayerReplicationInfo.Team.TeamIndex ] ()

# Change health indicator to reflect current health
HealthColor.G = int ( Pawn.Health / Pawn.HealthMax * HealthColor.G ) % 256
HealthColor.R = 255 - HealthColor.G

# Reset the canvas
Canvas.Reset ()

# Draw the player name
Canvas.DrawColor = TeamColor
if ( Pawn.PlayerReplicationInfo and ( not TeamGame or not self.SameTeam ( Pawn ) ) ):
Canvas.SetPos ( IndicatorPosition.X + 15, IndicatorPosition.Y - 15 )
Canvas.DrawText ( Pawn.PlayerReplicationInfo.PlayerName, False )

# Draw the team part of the indicator
Canvas.SetPos ( IndicatorPosition.X - 10, IndicatorPosition.Y - 4 )
Canvas.DrawTile ( self.WhiteTexture, 20.0, 8.0, 0, 0, self.WhiteTexture.USize, self.WhiteTexture.VSize )
Canvas.SetPos ( IndicatorPosition.X - 4, IndicatorPosition.Y - 10 )
Canvas.DrawTile ( self.WhiteTexture, 8.0, 20.0, 0, 0, self.WhiteTexture.USize, self.WhiteTexture.VSize )

# Draw the health part of the indicator
Canvas.DrawColor = HealthColor
Canvas.SetPos ( IndicatorPosition.X - 8, IndicatorPosition.Y - 2 )
Canvas.DrawTile ( self.WhiteTexture, 16.0, 4.0, 0, 0, self.WhiteTexture.USize, self.WhiteTexture.VSize )
Canvas.SetPos ( IndicatorPosition.X - 2, IndicatorPosition.Y - 8 )
Canvas.DrawTile ( self.WhiteTexture, 4.0, 16.0, 0, 0, self.WhiteTexture.USize, self.WhiteTexture.VSize )

# Helpers
def Valid(self, actor):
return not actor.bDeleteMe
def Invisible(self, actor):
PC = self.Viewport and self.Viewport.Actor
return PC and PC.GameReplicationInfo \
and PC.GameReplicationInfo.GameClass == 'KFXGame.KFXGhostGame' \
and actor.PlayerReplicationInfo and actor.PlayerReplicationInfo.Team \
and actor.PlayerReplicationInfo.Team.TeamIndex == TEAM_Red
def SameTeam(self, pawn):
PC = self.Viewport and self.Viewport.Actor
return PC and PC.GameReplicationInfo and PC.GameReplicationInfo.bTeamGame \
and PC.PlayerReplicationInfo and pawn.PlayerReplicationInfo \
and PC.PlayerReplicationInfo.Team == pawn.PlayerReplicationInfo.Team
def Damagable(self, pawn):
if ( pawn.Health <= 0 ): return False
return not pawn.KFXIsGodMode ()
def Gravity(self, actor):
# Make sure the actor is valid
if ( not actor or not actor.PhysicsVolume ): return Vector ()
# Fetch the zone gravity and add the supplementary pawn gravity
Acceleration = actor.PhysicsVolume.Gravity
if ( hasattr ( actor, 'ConstantAcceleration' ) ):
Acceleration += actor.ConstantAcceleration
return Acceleration
def Adjustment(self, actor, time):
# Make sure its a valid actor
if ( not actor ): return Vector ()
# Perform the time correction
if ( hasattr ( actor, 'Physics' ) and actor.Physics == PHYS_Falling ):
return self.Gravity ( actor ) * 0.5 * ( time * time ) + actor.Velocity * time
else: return actor.Velocity * time
def Correction(self, pc, actor, deltatime):
# Adjust for latency and player velocity
if ( not pc ): return Vector ( 0, 0, 0 );
return self.Adjustment ( actor, pc.ExactPing + deltatime ) - \
self.Adjustment ( pc.Pawn, deltatime )

# Event handlers
def OnTick(self, deltatime):
self.Tick ( deltatime )
def OnPostRender(self, canvas):
self.Viewport = canvas.Viewport
self.Render ( canvas )
def OnKeyDown(self, keycode, repeats, prevstate):
if ( keycode == self.AimKey ): self.KeyDown = True
def OnKeyUp(self, keycode):
if ( keycode == self.AimKey ): self.KeyDown = False

class Naming(object):
def __init__(self):
# Set some defaults
self.Interval = 1
self.Enabled = False
# Initialization
self.Viewport = None
self.Time = 0
self.Count = 0
def Enable(self, enabled = True):
self.Enabled = enabled
self.Count = 0
self.Time = 0
def OnTick(self, deltatime):
if ( not self.Enabled ): return
self.Time += deltatime
if ( self.Time > self.Interval ):
self.Time = 0
if ( self.Viewport and self.Viewport.Actor ):
value = self.Count % 256
name = ''.join ( reversed ( [ str((value >> bit) & 1) for bit in range ( 8 ) ] ) )
self.Viewport.Actor.ChangeName ( name )
self.Count += 1
def OnPostRender(self, canvas):
if ( canvas and canvas.Viewport ):
self.Viewport = canvas.Viewport

class Configuration(object):
# Internal settings
__config_layout = {
'Aiming' : [('aiming', [ 'AimKey', 'AimMode', 'AutoAim', 'AutoFire', 'FriendlyFire', 'LatencyCorrection', 'SecondaryFire', 'BonePrecedence' ])],
'Info' : [('aiming', [ 'AlwaysDraw', 'Wireframe', 'Wallhack' ])],
'Naming' : [('configuration', [ 'ChangedName' ]), ( 'naming', [ 'Enabled' ] )],
'Exploits' : [('configuration', [ 'PlayerScale' ])]
}

# Init/exit routines
def __init__(self):
# Globals for load/save
global configuration
configuration = self
# Set some defaults
aiming.AutoAim = True
aiming.AutoFire = True
aiming.LatencyCorrection = True
aiming.Wireframe = True
aiming.Wallhack = True
self.ChangedName = None
self.PlayerScale = 1.0
self.SaveInterval = 30
# Initialization
self.LastSave = 0
# Load settings and setup menu
self.__loadsettings ()
self.__setup_antweakbar ()

# Configuration presistence
def __loadsettings(self):
# Load and parse the settings file
filename = os.path.expandvars ( '%AppData%\\MAT Automaton\\settings.json' )
try: settings = json.load ( open ( filename, 'r' ) )
except: return
# Traverse configuration layout
for seclayout in self.__config_layout.items ():
# Fetch section object & data
try: section = settings [ seclayout [ 0 ] ]
except: continue
# Set settings from data
for objcfg in seclayout [ 1 ]:
obj = globals () [ objcfg [ 0 ] ]
for x in objcfg [ 1 ]: x in section and setattr ( obj, x, section [ x ] )
def __savesettings(self):
# Setup directory and file
dir = os.path.expandvars ( r'%AppData%\\MAT Automaton' )
if ( not os.path.exists ( dir ) ): os.mkdir ( dir )
filename = os.path.join ( dir, 'settings.json' )
try: outfile = open ( filename, 'w' )
except: return
# Build the settings dictionary
settings = {}
for seclayout in self.__config_layout.items ():
section = {}
for objcfg in seclayout [ 1 ]:
obj = globals () [ objcfg [ 0 ] ]
section.update ( dict ( map ( lambda x: (x, getattr ( obj, x )), objcfg [ 1 ] ) ) )
settings [ seclayout [ 0 ] ] = section
# Save settings to json settings file
json.dump ( settings, outfile, indent = 4 )

def __setup_antweakbar(self):
mainbar = AntTweakBar.TwGetBarByName ( "AimZa Team hack V.1" )
if ( mainbar ): AntTweakBar.TwDeleteBar ( mainbar )
try: mainbar = AntTweakBar.TwNewBar ( "AimZa Team hack V.1" )
except: return # Unknown AntTweakBar error
AntTweakBar.TwDefine ( " MATAutomaton label='MAT Automaton' color='255 0 0' fontSize='3' size='400 550' position='16 16' " )
AntTweakBar.TwAddVar ( mainbar, 'Key', AntTweakBar.TwDefineEnum ( 'EKey', [(k[1], k[0]) for k in Keys.dictionary.items ()] ), lambda : aiming.AimKey, lambda x : setattr ( aiming, 'AimKey', x ), " group='Aiming' label='Key' " )
AntTweakBar.TwAddVar ( mainbar, 'Mode', AntTweakBar.TwDefineEnum ( 'EAimModes', [(AIMING_Health, 'Health'), (AIMING_Distance, 'Distance'), (AIMING_Key, 'Key')] ), lambda : aiming.AimMode, lambda x : setattr ( aiming, 'AimMode', x ), " group='Aiming' label='Mode' " )
AntTweakBar.TwAddVar ( mainbar, 'AutoAim', AntTweakBar.TW_TYPE_BOOL32, lambda : aiming.AutoAim, lambda x : setattr ( aiming, 'AutoAim', x ), " group='Aiming' label='Auto Aim' " )
AntTweakBar.TwAddVar ( mainbar, 'AutoFire', AntTweakBar.TW_TYPE_BOOL32, lambda : aiming.AutoFire, lambda x : setattr ( aiming, 'AutoFire', x ), " group='Aiming' label='Auto Fire' " )
AntTweakBar.TwAddVar ( mainbar, 'BonePrecedence', AntTweakBar.TwDefineEnum ( 'EBones', [(BONE_Head, 'Head'), (BONE_Root, 'Root')] ), lambda : aiming.BonePrecedence, lambda x : setattr ( aiming, 'BonePrecedence', x ), " group='Aiming' label='Bone Precedence' " )
AntTweakBar.TwAddVar ( mainbar, 'SecondaryFire', AntTweakBar.TW_TYPE_BOOL32, lambda : aiming.SecondaryFire, lambda x : setattr ( aiming, 'SecondaryFire', x ), " group='Aiming' label='Secondary Fire' " )
AntTweakBar.TwAddVar ( mainbar, 'FriendlyFire', AntTweakBar.TW_TYPE_BOOL32, lambda : aiming.FriendlyFire, lambda x : setattr ( aiming, 'FriendlyFire', x ), " group='Aiming' label='Friendly Fire' " )
AntTweakBar.TwAddVar ( mainbar, 'LatencyCorrection', AntTweakBar.TW_TYPE_BOOL32, lambda : aiming.LatencyCorrection, lambda x : setattr ( aiming, 'LatencyCorrection', x ), " group='Aiming' label='Latency Correction' " )
AntTweakBar.TwAddVar ( mainbar, 'AlwaysDraw', AntTweakBar.TW_TYPE_BOOL32, lambda : aiming.AlwaysDraw, lambda x : setattr ( aiming, 'AlwaysDraw', x ), " group='Information' label='Always Draw' " )
AntTweakBar.TwAddVar ( mainbar, 'Wireframe', AntTweakBar.TW_TYPE_BOOL32, lambda : aiming.Wireframe, lambda x : setattr ( aiming, 'Wireframe', x ), " group='Information' label='Wireframe' " )
AntTweakBar.TwAddVar ( mainbar, 'Wallhack', AntTweakBar.TW_TYPE_BOOL32, lambda : aiming.Wallhack, lambda x : setattr ( aiming, 'Wallhack', x ), " group='Information' label='Wallhack' " )
AntTweakBar.TwAddButton ( mainbar, 'SwitchTeam', self.__switchteam, " group='Tools' label='Switch Team' " )
AntTweakBar.TwAddButton ( mainbar, 'CommitSuicide', self.__suicide, " group='Tools' label='Commit Suicide' " )
AntTweakBar.TwAddButton ( mainbar, 'OpenConsole', self.__openconsole, " group='Tools' label='Open Console' " )
AntTweakBar.TwAddVar ( mainbar, 'Name', AntTweakBar.TW_TYPE_BOOL32, lambda : naming.Enabled, lambda x : naming.Enable ( x ), " group='Tools' label='Random Name' " )
AntTweakBar.TwAddVar ( mainbar, 'PlayerName', AntTweakBar.TW_TYPE_CDSTRING, self.__getplayername, self.__changeplayername, " group='Tools' label='Player Name' " )
AntTweakBar.TwAddButton ( mainbar, 'GodMode', self.__setpawnbit ( EPB_God ), " group='Exploits' label='God Mode' " )
AntTweakBar.TwAddVar ( mainbar, 'PlayerScale', AntTweakBar.TW_TYPE_FLOAT, lambda : self.PlayerScale, lambda x : setattr ( self, 'PlayerScale', x ), " group='Exploits' label='Player Scale' step=0.1 " )
AntTweakBar.TwAddButton ( mainbar, 'SetScale', self.__setscale, " group='Exploits' label='Set Scale' " )

# Tool routines
def __getplayername(self):
PC = aiming.Viewport and aiming.Viewport.Actor
PRI = aiming.Viewport and aiming.Viewport.Actor and aiming.Viewport.Actor.PlayerReplicationInfo
ChangedName = not naming.Enabled and self.ChangedName or None
if ( PC and PRI and ChangedName and ChangedName != PRI.PlayerName ):
PC.ChangeName ( ChangedName )
return ChangedName or ( PRI and PRI.PlayerName ) or 'None'
def __changeplayername(self, value):
self.ChangedName = value.replace ( ' ', '_' )
def __suicide(self):
PC = aiming.Viewport and aiming.Viewport.Actor
if ( PC ): PC.Suicide ()
def __switchteam(self):
PC = aiming.Viewport and aiming.Viewport.Actor
if ( PC ): PC.SwitchTeam ()
def __openconsole(self):
Console = aiming.Viewport and aiming.Viewport.Console
if ( Console ): Console.ConsoleOpen ()

# Exploit routines
def __setpawnbit(self, pawnbit):
def function():
Pawn = aiming.Viewport and aiming.Viewport.Actor and aiming.Viewport.Actor.Pawn
if ( Pawn ): Pawn.KFXSetPB ( pawnbit )
return function
def __setscale(self):
PC = aiming.Viewport and aiming.Viewport.Actor
if ( PC ): PC.ServreSetOwnScale ( self.PlayerScale )

# Event handling
def OnTick(self, deltatime):
self.LastSave += deltatime
if ( self.LastSave > self.SaveInterval ):
self.LastSave = 0
self.__savesettings ()
def OnKeyDown(self, keycode, repeats, prevstate):
if ( keycode == Keys.Numpad0 ):
aiming.AutoAim = not aiming.AutoAim
Logger.Log ( 'Auto aiming is now %s!' % ( aiming.AutoAim and 'on' or 'off' ) )
elif ( keycode == Keys.Numpad1 ):
aiming.Wallhack = not aiming.Wallhack
Logger.Log ( 'Wallhack is now %s!' % ( aiming.Wallhack and 'on' or 'off' ) )
elif ( keycode == Keys.Numpad2 ):
aiming.Wireframe = not aiming.Wireframe
Logger.Log ( 'Wireframe is now %s!' % ( aiming.Wireframe and 'on' or 'off' ) )
elif ( keycode == Keys.Numpad3 ):
aiming.AutoFire = not aiming.AutoFire
Logger.Log ( 'Auto firing is now %s!' % ( aiming.AutoFire and 'on' or 'off' ) )
elif ( keycode == Keys.Numpad5 ):
aiming.SecondaryFire = not aiming.SecondaryFire
Logger.Log ( 'Secondary firing is now %s!' % ( aiming.SecondaryFire and 'on' or 'off' ) )
elif ( keycode == Keys.Delete ):
if ( aiming.Viewport and aiming.Viewport.Console ):
aiming.Viewport.Console.ConsoleOpen ()
def OnMenuShow(self):
PC = aiming.Viewport and aiming.Viewport.Actor
GUI = PC and aiming.Viewport.Actor.Player and aiming.Viewport.Actor.Player.GUIController
if ( GUI ):
GUI.OperateMsgs [ 99 ] = 'M.A.T. Automaton For Server Thai Modify BY AimZA.'
GUI.OpenModeDialogue ( 99 )
def OnMenuHide(self):
PC = aiming.Viewport and aiming.Viewport.Actor
GUI = PC and aiming.Viewport.Actor.Player and aiming.Viewport.Actor.Player.GUIController
if ( GUI ):
GUI.CloseModeDialogue ()
if ( not GUI.MenuStack ):
GUI.bActive = False
GUI.bVisible = False
try: GUI.ViewportOwner.bShowWindowsMouse = False
except: pass

class Startup(object):
def __init__(self):
self.started = False

def Startup(self):
# Mark aiming/configuration as globals
global aiming, naming, configuration

# Instantiate and register
aiming = Aiming ()
naming = Naming ()
configuration = Configuration ()
Register ( aiming )
Register ( naming )
Register ( configuration )

def OnTick(self, deltatime):
# Check status
if ( self.started ): return
self.Startup ()
self.started = True

# Instantiate startup handler
Register ( Startup () )

Hey plz create a video and upload to Youtube. And post the link here plz.

is it copy and paste in to the Script OR create a new .atpy and then paste this script inside?

i understand the things a little bit. but dont i need to edit the scripts and test it?

guys i cant find the force alernative can anyone help me ?

weh hang dah buat video ka belom ?? kalau dah kasi aq link dia

Please make the Video Fast!

OutdatedMAT Automation Unblock Script

Similar Threads

Tags for this Thread