Mensajes

"hacked by W4rR3d <autodidacta en ingenieria de sistemas y creador de virus informaticos> Piura - Peru"


¿Autodidacta en Ingeniería en Sistemas? ¿Qué edad tenés? ¿Qué ingeniero en sistemas usa batch para algo así, y encima de tan bajo nivel?


S0Y R3 K4K3R... Dios mío...

 No era eso, pero gracias, acabo de encontrar, lo hize con:

Código (python) [Seleccionar] Expandir


if not (Extra):
[...]


Gracias Nov, te lo agradezco

 Está muy bien el programa che. Es interesante, buen aporte.

PD: ¿Por qué "Elephant"? jaja

 Tengo una enorme duda, yo tengo el siguiente código:

Código (Python) [Seleccionar] Expandir


class Control:
       def __init__(self, *Extra):
[...]


¿Cómo se verifica si se le pasó parámetros extra? Yo lo que quiero hacer dentro es que, si se le pasaron parámetros, en base a esos parámetros se hagan algunas cosas, pero para eso necesito verificar si hay algo en la tupla "Extra". Cómo hago eso? u.u Es con "not"? No logro hacerlo :S

 No podés hacer que el bat se ejecute X tiempo después de haber sido ejecutado ("doble clickeado"). Vos lo que debés estar diciendo es que se ejecuten X comandos a determinado tiempo. Con AT se puede, poné AT /? en el CMD. Pero no es que el bat va a quedar oculto hasta esa hora eh ni nada por el estilo.... La ayuda la tenés en el CMD

help AT
AT /?


Saludos.

 Estoy intentando entender como diantres funciona un programa para cambiar los íconos de cualquier archivo jeje. Busqué un source para ver como funciona, y sólo encontré uno en VB (Lenguaje que no manejo), y no logro entender qué es lo que hace. Como que lee un ejecutable o algo así. Realmente no entiendo. ¿Qué debería leer para entenderlo? Porque no se qué "cosa" buscar para leer acerca de esto. O sea, ¿Cómo busco documentación en la que explique como funciona esto? u.u Porque quiero entender como funciona, así me hago mi cambiador de íconos en Python n.n (con las APIs obvio, que tampoco las encuentro xD)

Gracias de antemano n.n

V de Venganza, ahora salgo a matar fascistas con los cuchillos de mi vieja. No mentira, pero el personaje, si uno lo analiza es muy interesante. Y realmente muestra cosas muy lindas, sacando toda la trama y fantasía.
Después, Tiempos Modernos de Chaplin, y Candilejas. No me la cambiaaaaron, pero me sirvieron de mucho.

 [edit] ¿Cómo le pongo color al código?
Bueno, edito el mismo post. Ya solucioné mis dudas, leí, entendí y estoy haciendo mi módulo (ya hace unos días) con varias funciones raras Pienso ponerle muchas cosas, hasta ahora tiene:
-Armado de menúes (Ahora estoy trabando en el armado de menúes con contexto)
-Armado de cajas de texto (con recuadros ASCII Extendidos)
-Marquesina de textos (Textos en movimiento, los cuáles voy a mejorar)
-Manejo de color en consola: Obtener atributs de texto, cambiarlos, etc.
-Obtención de valores: Se puede pasra una lista de cadenas, y devuelve la de menor y mayor longitud, o se puede pasar números y da el mayor y el menor, en una tupla.
-Tiene otros "dos print", ilprint para mostrar un mensaje con otro color, sin cambiar el color de la consola, es decir, cambia solopara mostrar el texto y vuelve a la normalidad y "olprint" que es lo mismo, solo que muestra el texto seguido (equivalente a sys.stdout.write)
-Invertir cadenas
-Muestra mensajes con beepeo
Y estoy trabajando en:
Barra de progreso
Inputboxes (Con recuadros ascii)
Animaciones ascii
Relojes (TAmbién en ASCII, toda la onda)
Y estoy modificando un programa mío para resolver cosas de matemática, y poderlo aplicar
Es una newbiada, y tiene cosas que están de mas, pero es porque forman parte de lo que estoy agregando
tiene un par de variables definidas, como líneas, y cosas así Véanlo en el código, después voy a hacer un texto sobre como usarlo Es una newbiada total, y espero que algunos sabiondos puedan corregirme n.n Hay cosas que repito ESTÁN DE MAS pero porque van a formar parte de otra cosa que estoy armando
Y también puse de dónde aprendí eso

Código (python) [Seleccionar] Expandir


# -*- coding: cp1252 -*-
#--------------------------------------------
#Autor: GeSeM (S3KH)   Grisolía Emilio.
# Se permite la modificación, y edición de jazzer. Dejando a la moral de cada uno el hecho de mantener o no los créditos.
#Prohibido distribuirlo compilado SIN el fichero de texto, puesto que es código abierto.
#Programado en Python 2.7.
#--
#Versión 2.0
# Espero, pueda servirles un poco...!
#                                    Septiembre, 2011. Argentina.
#--------------------------------------------

print 'Cargando Jazzer...'
print 'Cargando datos... 100%'
ERROR01 = 'Error (Argumento invalido): '
ERROR02 = 'Error (Función inexistente): '
ERROR03 = 'Error (Dato/s invalido/s): '
VAR     = 'VAR'
n       = '-n'
endl    = 'endl'



print 'Cargando (modulos)... 100%'


#--- MÓDULOS IMPORTADOS ---#

import os, time, math, cmath, sys
print 'Cargando ctypes... 100%'
from ctypes import *

#-- El uso de ctypes brinda la posibilidad de poder usar las APIs de Windows, entre demás prestaciones de C

#------------CONSTANTES (WIN32API)------------------------#

print 'Cargando jazzer (GENERIC_READ)... 100%'
#GENERIC_READ

STD_INPUT_HANDLE     = -10
STD_OUTPUT_HANDLE    = -11
STD_ERROR_HANDLE     = -12

#-- Tipos de dato C
print 'Cargando datos C... 100%'
Short                = c_short
uShort               = c_ushort
Long                 = c_long

#-- HWND (GetStdHandle)
print 'Cargando HWND_STD(IO)... 100%'
HWND_StdOut          = windll.kernel32.GetStdHandle(STD_OUTPUT_HANDLE)
HWND_StdIn           = windll.kernel32.GetStdHandle(STD_INPUT_HANDLE)


#------------CONSTANTES (COLORES)--------------------------#
# Dados en formato hexadecimal                             #
#----------------------------------------------------------#
print 'Cargando colores... 100%'
FOREGROUND_BLACK     = 0x0000
FOREGROUND_BLUE      = 0x0001
FOREGROUND_GREEN     = 0x0002
FOREGROUND_CYAN      = 0x0003
FOREGROUND_RED       = 0x0004
FOREGROUND_MAGENTA   = 0x0005
FOREGROUND_YELLOW    = 0x0006
FOREGROUND_GREY      = 0x0007
FOREGROUND_INTENSITY = 0x0008 # Color de texto intensificado
BACKGROUND_BLACK     = 0x0000
BACKGROUND_BLUE      = 0x0010
BACKGROUND_GREEN     = 0x0020
BACKGROUND_CYAN      = 0x0030
BACKGROUND_RED       = 0x0040
BACKGROUND_MAGENTA   = 0x0050
BACKGROUND_YELLOW    = 0x0060
BACKGROUND_GREY      = 0x0070
BACKGROUND_INTENSITY = 0x0080 # Fondo de texto intensificado

#-------------------------------------------------------------#

#-------- Carácter de emisión de sonido
beep                 = chr(7)




#----- CONSTANTES (Gráficas) ----------------------------------#

print 'Constantes graficas... 100%'
#----- LÍNEAS (ASCII EXTENDIDO) -----#

# Usadas para la construccion de menúes

# formato de constante:
# Las constantes de las líneas se componen de un prefijo "l", seguido de una S o una D
# para indicar si es simple(S) o doble(D). Finalmente, un juego de 3 letras indica cuál caracter es:

#-- ES(I/D) = Esquina Superior (Izquierda o Derecha)
#-- EI(I/D) = Esquina Inferior (Izquierda o Derecha)
#-- HOR     = HORizontal
#-- VER     = VERtical
#-- CRZ     = CRuZ
#-- T(DI/ID)= "T" (Derecha>Izquierda / Derecha<Izquierda) (Línea "T" que apunta hacia un lado)
#-- LT(B/A) = Línea T (Baja / Alta) (De abajo hacia arriba / De arriba hacia abajo)

#----------LÍNEAS DOBLES---------------------------#
lDESI    = chr(201) #-- Esquina superior izquierda
lDESD    = chr(187) #-- Esquina superior derecha
lDEID    = chr(188) #-- Esquina inferior derecha
lDEII    = chr(200) #-- Esquina inferior izquierda

lDVER    = chr(186) #-- Línea doble vertical
lDHOR    = chr(205) #-- Linea doble horizontal

lDLTA    = chr(203) #-- Línea "T" (Arriba)
lDLTB    = chr(202) #-- Línea "T" (Abajo)
lDTID    = chr(185) #-- Línea "T" (Izquierda>Derecha)
lDTDI    = chr(204) #-- Línea "T" (Derecha>Izquierda)

lDCRZ    = chr(206) #-- Linea doble "cruz"

#----------LÍNEAS SIMPLES---------------------------#
lSEII    = chr(192) #-- Esquina inferior izquierda
lSESI    = chr(218) #-- Esquina superior izquierda
lSESD    = chr(191) #-- Esquina superior derecha
lSEID    = chr(217) #-- Esquina inferior derecha

lSVER    = chr(179) #-- Línea vertical
lSHOR    = chr(196) #-- Línea horizontal

lSTID    = chr(195) #-- Línea "T" (Izquierda>Derecha)
lSLTB    = chr(193) #-- Línea "T" (abajo)
lSLTA    = chr(194) #-- Línea "T" (arriba)
lSTDI    = chr(180) #-- Linea "T" (Derecha>Izquierda)

lSCRZ    = chr(197) #-- Línea "cruz"


#----------------GRÁFICOS---------------------------#
# Carácteres que son usados para rellenar espacios
# o gráficos, animaciones, etc
#----------------------------------------------------#

fill_1           = chr(176) #-- Menos saturado
fill_2           = chr(177)
fill_3           = chr(178)
fill_4           = chr(219) #-- Mas saturado
#--
fill_5           = chr(220)
fill_6           = chr(221)
fill_7           = chr(222)
fill_8           = chr(223)
blank            = ' '
P                = '.'
D1, D2           = '<', '>'
line             = chr(10)

print 'Secuencias (animaciones)... 100%'
#---------SECUENCIAS--------------------------------#
# Las animaciones son secuencias de carácteres
# que mostrados (respetando dicha secuencia)
# generan "imágenes" en movimiento.
# Se almacenan en listas, para ser impresas
# siguiendo el orden en ellas.
#----------------------------------------------------#

ANIM01           = [P, P*2, P*3]                    #Secuencia de 3 puntos suspensivos
ANIM02           = [D1, D1*2, D1*3]                 #Secuencia con los direccionales (<)
ANIM03           = [D2, D2*2, D2*3]                 #Secuencia con los direccionales (>)
ANIM04           = [fill_1, fill_2, fill_3, fill_4] #Secuencia con carácteres de relleno
ANIM05           = ['\\', lSVER*2, '/', lSHOR*2]    #Secuencia de barra giratoria
ANIM06           = [blank, D1]                      #Prompt titilante



print 'Cargando controles... 100%'
#----------CONSTANTES DE CONTROLES------------------#
# Hay disponibles los siguientes "controles":
# Cajas de aviso
# Cajas de ingreso de datos
# Relojes (Numeración romana, occidenta (Analógica / Digital)
# Barras separadoras
#---------------------------------------------------#
# Próximamente (Barras de progreso, animaciones ASCII)
# Y mas...!


#--CAJAS DE TEXTO (Marco doble) (Argumentos)

DBox  = 'DBox'
DDBox = 'DDBox'
DIBox = 'DIBox'
D1Box = 'D1Box'
D2Box = 'D2Box'


#--CAJAS DE TEXTO (Marco simple) (Argumentos)

SBox  = 'SBox'
SDBox = 'SDBox'
SIBox = 'SIBox'
S1Box = 'S1Box'
S2Box = 'S2Box'

#Lista de cajas

Boxes = [DBox, DDBox, DIBox, D1Box, D2Box, SBox, SDBox, SIBox, S1Box, S2Box]

#------------- Relojes ----------------------#
CLOCK_OCC   = 'CLOCK_OCC'
CLOCK_ROM   = 'CLOCK_ROM'

DIGITAL   = 'DIGITAL'
ANALOGIC = 'ANALOGIC'

FORM12    = 'FORM12'    #Formato de 12horas
FORM24    = 'FORM24'    #Formato de 24horas

sContext = 'sRecuadro' #Sin recuadro
Context1 = 'Recuadro1' #Recuadro rectangular o cuadrado
Context2 = 'Recuadro2' #Recuadro circular o redondeado

NUM_OCC12 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
NUM_OCC24 = NUM_OCC12
iN = 13
while (iN <= 24):
    NUM_OCC24.append(iN)
    iN += 1


NUM_ROM  = {1:'I',
            2:'II',
            3:'III',
            4:'IV',
            5:'V',
            6:'VI',
            7:'VII',
            8:'VIII',
            9:'IX',
            10:'X',
            11:'XI',
            12:'XII'
            }



#---------------------------------------------#






print 'Cargando estructuras C... 100%'
#-------------------------------------------------------------------------------------#

#--ESTRUCTURAS C------------------------------#
# Las estructuras C son utilizadas
# junto con ctypes para poder invocar funciones
# del sistema operativo, que necesiten apuntar
# a estructuras de datos
#-----------------------------------
# Visitar MSDN y documentación de Python para mas información.

#----------------------Console (ScreenBufferInfo)

class COORD(Structure):           #-- Estructura para coordenadas.
        _fields_ =[
                ('X', Short),
                ('Y', Short)
                  ]

class SMALL_RECT(Structure):       #-- Estructura para posiciones.
        _fields_ =[
                ('Left', Short),
                ('Top', Short),
                ('Right', Short),
                ('Bottom',Short)
                  ]
       
class CONSOLE_SCREEN_BUFFER_INFO(Structure):
        _fields_ =[
                ('dwSize', COORD),
                ('dwCursorPosition', COORD),
                ('wAttributes', uShort),
                ('srWindow', SMALL_RECT),
                ('dwMaximumWindowSize', COORD)
                  ]


print 'Cargando funciones... (Misc)'
#--- Reversión de una cadena
#--- (Argumento = Cadena)
def strReverse(String):
        reversedString = ''
        reverseIndex  = -1
        abs_maxCount  = abs(len(String))
        while (abs(reverseIndex) <= abs_maxCount):
            reversedString = reversedString + String[reverseIndex]
            reverseIndex -= 1
        return reversedString

#--- Obtención de cadena de mayor y menor longitud, o número mas grande y mas chico
#--- Devuelve una tupla, siendo elemento 0 el mayor y 1 el menor.
#--- Los arugmentos son: 'str', 'num', para indicar si se trabaja con una cadena o números.
#--- Traspasar cualquier cantidad de cadenas/números
def GetValues(valueType, *Values):
        valTypes = ('str', 'num');
        if not (valueType in valTypes): return ERROR01+valueType;   
        if (valueType==valTypes[0]):
                maxStr, minStr = '', '';
                lenValues      = len(Values);
                Count          = 0;
                maxCount       = (lenValues - 1);
                while (Count < maxCount):
                        if (len(Values[Count]) > len(Values[Count+1])):
                                maxStr=Values[Count];
                                minStr=Values[Count+1];
                        elif (len(Values[Count]) < len(Values[Count+1])):
                                maxStr=Values[Count+1];
                                minStr=Values[Count];
                        Count += 1;
                return maxStr, minStr;
        elif (valueType==valTypes[1]):
                tmpMenor = 0
                tmpMayor = 0
                longitudValores    =len(Valores)
                Contador           = 0
                maxContador        = (longitudValores-1)
                while (Contador < maxContador):
                        if (Valores[Contador] >= Valores[Contador+1]):
                                tmpMayor = Valores[Contador]
                                tmpMenor = Valores[Contador+1]     
                        elif (Valores[Contador] <= Valores[Contador+1]):
                                tmpMayor = Valores[Contador+1]
                                tmpMenor = Valores[Contador]
                        Contador += 1
                return tmpMayor, tmpMenor


print 'Cargando funciones (WINAPI32)...100%'
#------------------------------FUNCIONES---------------------------------#

#--- Manejo de consola (Color e información)
#--- No necesita argumentos, devuelve el color de consola.
def GetConsoleColor():
        GConsoleScreenBufferInfo = CONSOLE_SCREEN_BUFFER_INFO()
        windll.kernel32.GetConsoleScreenBufferInfo(HWND_StdOut, byref(GConsoleScreenBufferInfo))
        return hex(GConsoleScreenBufferInfo.wAttributes)
#--- Argumento = Color
def SetConsoleColor(Color):
        bool = windll.kernel32.SetConsoleTextAttribute(HWND_StdOut, Color)
        return bool






#-------------------------------------------------------------------------#


print 'Cargando funciones de cálculo lineal... 100%'
class Lineal:
# Cálculo líneal
    def __init__(self, a, b, c):
        self.a = a
        self.b = b
        self.c = c
# Obtención de discriminante
    def Discriminante(self):
        Discriminante = self.b*self.b -4*self.a*self.c
        return Discriminante
# Obtención de raices (Soporte para raices en campo complejo)   
    def raices(self):
        Discriminante = self.b*self.b -4*self.a*self.c
        if (Discriminante < 0):
                real = -self.b/(2*self.a)
                imag = math.sqrt (-Discriminante)/(2*self.a)
                return 'Im', 'X1', real, imag, 'X2', real, imag
        elif (Discriminante > 0):
                X1 = (-self.b + math.sqrt (Discriminante))/(2*self.a)
                X2 = (-self.b - math.sqrt (Discriminante))/(2*self.a)
                return '2', X1, X2
        elif (Discriminante == 0):
                X = -self.b/(2*self.a)
                return '1', X


#-----------Draws--------------------------------------------------------#
def pchar(char): sys.stdout.write(char);

def iprint(Color, jline, *iText):
        def tpchar(Text):
            for item in Text: pchar(str(item));
        if (Color != n):
            prevColor = hex(GetConsoleColor());
            SetConsoleColor(Color);
        Count     = 0;
        fText     = [];
        for item in iText:fText.append(str(item));
        for item in fText:tpchar(str(item));
        if (Color != n):
            SetConsoleColor(prevColor);
        if (jline == endl):
            print line

class Draw:
        def __init__(self, *Args):
            self.Args = Args   #-- En construcción
   
#----------CONTROLES------------------------------------------------------#


print 'Cargando controles... 100%'

   


class Control:
        def __init__(self, *Options):
                if not (Options):
                    pass;

                lnOptions = len(Options)
                #-- En construcción
                   
                   

               

        def Box(self, Color, Sound, Stop, Text, box):
                if not (box in Boxes):
                        x = Control()
                        Control.sbox(x, 0xC, 0, 1, 'Error <box inválido>', DBox)
                lenLDH  = lDHOR*len(Text)
                txtLn   = lDVER+Text+lDVER
                prevColor = GetColor()
                SetConsoleColor(Color)
                #-- Verificación argumento caja --#
                if (box == DBox):
                        print lDESI+lenLDH+lDESD+line+txtLn+line+lDEII+lenLDH+lDEID
                        SetConsoleColor(prevColor)
                        if (Sound == 1): sys.stdout.write(chr(7))
                        if (Stop == 1): raw_input()
                elif (box == DDBox):
                        print lDESI+lenLDH+lDLTA+line+txtLn+line+lDEII+lenLDH+lDLTB
                        SetConsoleColor(prevColor)
                        if (Sound == 1): sys.stdout.write(chr(7))
                        if (Stop == 1): raw_input()
                elif (box == DIBox):
                        print lDLTA+lenLDH+lDESD+line+txtLn+line+lDLTB+lenLDH+lDEID
                        SetConsoleColor(prevColor)
                        if (Sound == 1): sys.stdout.write(chr(7))
                        if (Stop == 1): raw_input()
                elif (box == D1Box):
                        print lDHOR+lenLDH+lDHOR+line+Texto+line+lDHOR+lenLDH+lDHOR
                        SetConsoleColor(prevColor)
                        if (Sound == 1): sys.stdout.write(chr(7))
                        if (Stop == 1): raw_input()
                elif (box == D2Box):
                        print lDVER+(blank*len(Texto))+lDVER+line+lDVER+Texto+lDVER+line+lDVER+(blank*len(Texto))+lDVER;
                        SetConsoleColor(prevColor);
                        if (Sound == 1): sys.stdout.write(chr(7));
                        if (Stop == 1): raw_input();


 Haceme saber cuándo la tengas jejej De nada Leminy, un gusto n.n!

 Si leí eso pero no logro entenderlo jejej, voy a ojearlo mejor eso n.n Muchas gracias !!!

EDIT:
¿Y esto?
lpConsoleScreenBufferInfo [out]
A pointer to a CONSOLE_SCREEN_BUFFER_INFO structure that receives the console screen buffer information.

O_O Estoy en el horno me parece jeje

EDIT2: Me parece que necesito un curso intesivo de APIs. JAJA, si, ya encontré lo qu necesito, pero no entiendo como aplicarlo en Python... jejeje, pero bueno. Ya encontré la función. Tendré que leer demasiado... Je, muchas gracias!!!!