Temas

 Espero no estar en el lugar equivocado del foro...

Tengo un juego (Tierras del Sur, Argentum Online), el cual posee una interface gráfica que deseo editar. Al parecer (Muy obvio), está en un archivo (denominado interface.TDS). ¿Cómo empiezo a editarlo? Es decir, ¿cómo se que tipo de archivo es? Básicamente, quiero modificar el aspecto gráfico nada mas. ¿Alguna pista?

EDIT: Nada mas necesito una mínima orientación de como saber "qué es" ese archivo, no pido mas que eso Mientras sigo averiguando por otro laditos.

 Estoy relojeando MSDN,  y me propuse hacer un cambiador de íconos (Utilizo Python, pero no viene al caso).  Realmente no sé por dónde comenzar a buscar. Es decir, ¿Cómo se cambia el ícono de un archivo cualquiera? ¿Existe alguna API para eso? ¿En qué temas me tengo que informar? No vengo a pedir códigos ni nada (A menos que sea necesario), sólo un poco de orientación para poder ubicarme y comenzar a investigar.
(Estoy en Windows XP, por si interesa)

Muchas gracias de antemano, y un cordial saludo.

 Buenas noches. Intenté hacer un pequeeño e inútil programa, el cuál se le da un numero, un rango, un valor de incremento y un valor de decremento, y el dá un resultado. Por ejemplo:

Numero: 10
Rango: 7
Valor decremento: 0.7
Valor incremento: 3

Es decir, mostrará 7 valores anteriores descontando de a 0.7 y 7 valores posteriores incrementando de a 3:

9.3 8.6 7.9 7.2 6.5 5.8 5.1 ... Y por otro lado mostrará 13 16 19 22 25 28 31

El programa funciona, pero quisiera saber si cometí algún error, o algún detalles, alguna sugerencia o lo que fuere Muchas gracias de antemano!

Código (cpp) [Seleccionar] Expandir


#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
using namespace std;
//Prototipos
int Menu_Principal();
//MAIN
int main() {
    Menu_Principal();
    getch();
return 0;
}
//Principal
int Menu_Principal() {
  double Numero, decVal, incVal;
  int Rango, Contador, Opcion;
  Contador = 1;
    cout << "Numero: "; cin >> Numero;
    cout << "Rango: "; cin >> Rango;
    cout << "Decrementar en: "; cin >> decVal;
    cout << "Incrementar en: "; cin >> incVal;
    cout << endl;
        //////////////////////////
        //Anteriores             /
        //////////////////////////
        cout << "ANTERIORES A " << Numero << endl;
        while (Contador <= Rango) {
            cout << Numero - (Contador * decVal) << " ";
            Contador += 1;
        }
        //////////////////////////
        //Posteriores            /
        //////////////////////////
        cout << endl << endl << "POSTERIORES A " << Numero << endl;
        Contador = 1;
        while (Contador <= Rango) {
            cout << Numero + (Contador * incVal) << " ";
            Contador += 1;
        }
    cout << endl << endl;
    cout << "1- Salir" << endl;
    cout << "2- Otro numero" << endl;
    cin >> Opcion;
    if (Opcion == 1) exit(0);
    else Menu_Principal();
return 0;
}


 Ya lo puse en el posteo del Videotutorial de C++, la cuestión es que a partir del enlace 12 inclusive no funcionan, acá encontré un link de 900mb aprox con todos los capítulos, pero como muchos no van a leer lo que comenté en el otro post, me gustaría pedir si algún mod o algo agregue este enlace o algo. Perdonen que arme un tema para esto, pasa que quizás otros necesitan el VT.

NO SUBÍ YO EL ENLACE, solo lo encontré y tiene todos los caps (Y funciona):

http://www.4shared.com/get/J0bkzFQM/videotutorial_de_c_por_shevche.html;jsessionid=D730E7069290D4E44251E217E65FBFD7.dc323

Mis disculpas de nuevo por la molestia n_n

 Es posible poder ejecutar diversas instrucciones "al mismo tiempo" en Python? Es decir, tengo programado un "intento de reloj" para consola, y ahora estoy entre 2 cosas:
-Que mientras el usuario vaya ingresando el número de opción,  el reloj siga corriendo a un costado.
Creo que se llama ejecutar algo en background o tengo mal entendido las cosas. Es posible hacer esto?

 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

 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

 [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();


 Qué tal gente? Espero me puedan ayudar, lo agradecería de corazón.

¿Existe alguna función de Windows que me permita obtener los atributos de consola, como el color de texto y fondo? Se de "SetConsoleTextAttributes", y otras para obtener atributos de fuente, pero no da el color.

Desde ya, agradecería mucho cualquiera ayuda

Un abrazo.

 Gente, programando en Python estoy usando las APIs para hacer un par de cosilias, y me veo con la necesidad de guardar los atributos del texto de la consola (Color y fondo). Usé SetConsoleTextAttribute para cambiar el color, pero yo desearía saber si hay alguna función que me devuelva esos atributos, para poder restaurarlos luego. La razón por la cuál no lo pongo en scripting es que esto es mas general, porque necesito saber una función que se ocupe de esto. Pensé que habría algo como GetConsoleTextAttribute, pero no No hay Si alguien me pudiera aunque sea decir el nombre, yo lo demás lo puedo buscar u.u Un abrazo gente, y gracias de antemano u.u

No es de Python la duda. Sólo busco la función (Lo cuál sería válido hasta para C, ASM etc)

 Hola gente, estoy intentando entender por qué el siguiente código no me da resultado, ni error siquiera.
Estyo realizando mi propio módulo de funciones "útiles", aunque de novato, y una de ellas es para cambiar el fondo y color de un texto. Mi módulo es llama "jazzer", y dentro de este estoy implementando funciones de marquesina, efectos de texto (en consola), etc. El módulo contiene definidas algunas variables que hacen referencia a los colores y sus valores correspondientes. Cada una tiene un prefijo (l o d) que hace referencia a la intensidad (l para light o brillante, y d para dark u oscuro), y el nombre del color. Dejo el código (Sacando lo que no intefiere), y posteriormente mi duda:

Código [Seleccionar] Expandir


import ctypes
#-- DATOS --#
#--Constantes de colores--
#--Variantes oscuras
BLACK   ='0'
dBLUE   ='1'
dGREEN  ='2'
dCYAN   ='3'
dRED    ='4'
dPURPLE ='5'
dYELLOW ='6'
dWHITE  ='7'
dGREY   ='8'
#--Variantes claras
lBLUE   ='9'
lGREEN  ='A'
lCYAN   ='B'
lRED    ='C'
lPURPLE ='D'
lYELLOW ='E'
lWHITE  ='F'

#-Manejo de colores en consola
def hValColor(Color):
        #WinAPI (kernel32.dll). GetStdHandle
        STD_INPUT_HANDLE  = -10
        STD_OUTPUT_HANDLE = -11
        STD_ERROR_HANDLE  = -12
        std_out_handle = ctypes.windll.kernel32.GetStdHandle(STD_OUTPUT_HANDLE)
        bool = ctypes.windll.kernel32.SetConsoleTextAttribute(std_out_handle, Color)
        return bool

def cValColor(FOREGROUND, BACKGROUND):
        Color = '0x'+FOREGROUND+BACKGROUND
        hValColor(Color)


Verán, uso dos funciones para definir el color hValColor y cValColor. La diferencia radica en que hValColor recibe un parámetro hexadecimal correspondiente al color (0xA por ejemplo), mientras que la otra recibe los colores en el formato <prefijo><Color>, (lBLUE por ejemplo). Esto lo hize pensando en un usuario que desconozca el código hexadecimal, de modo que pueda especificar el color de otra forma.
SetConsoleTextAttribute admite un código hexadecimal sea o no sea string, hize la prueba pasando un parámetro cadena ('0xA') y otro hex (0xA). Ambos dieron resultado.
Ahora bien, implementando eso en cValColor, en teoría debería concatenar 0x, FOREGROUND y BACKGROUND, almacenarlas en Color y pasarlas a hValColor, y este cambiaría el color. Explico mejor:

Código [Seleccionar] Expandir


from jazzer import *
cValColor(lBLUE, dGREEN)


En cValColor se reemplazaría lBLUE por su cadena correspondiente; pasando lo mismo con dGREEN, y luego, concatenando ambos a "'0x". El tema es que el ejecutarse esto, el color sigue igual, y no devuelve ningún error. ¿Por qué? Es decir, SetConsoleTextAttributes SEGÚN LO QUE PROBÉ puede recibir un hexadecimal en cadena o no, y da el mismo resultado. Acá, el traspaso debería ser una cadena, y sin embargo, no da error ni resultado.
Cualquier ayuda me serviría. DEsde ya muchas gracias si se tomaron el tiempo de leerlo.

Un abrazo.

 Antes que nada, quisiera dejar en claro que mi intención no es saber cómo, si no, el por qué.
Buscando en Google sólo doy con links que me dicen que programa usar, me hablan del USO de proxys y demás. Mi intención va mas allá de eso, y quisiera saber por donde debería empezar para poder entenderlo. Es decir, vi el programa Cyberghost, para navegar oculto. Lo que me gustaría saber es qué conceptos se deben entender para entender el funcionamiento del programa, por ejemplo.
¿Qué temas debo leer para comenzar a entender como funciona esto? (Mi objetivo es, algún día, poder hacer un programa que me permite navegar oculto (En Python jeje). Pero necesito entender primero).
Por favor, no me den códigos de ejemplo, ni nada. Sólo conceptos que debería buscar, ya que no se por dónde empezar. No importa si son temas largos, sólo quiero aprender. Y disculpen si esta pregunta es una peteada, realmente estoy iniciado hace poco en este tema.

Un abrazo, y gracias de antemano. Y también disculpen si me equivoqué de sección... Je...

 Alguien que tenga experiencia o conocimientos acerca del ámbito laboral en lo que a desarrollo de software concierne, Python es buen visto? Es usado hoy día por empresas EN ARGENTINA? (Se que Google y la NASA lo usan).
Y si no es así, qué lenguajes son mas buscados? Además de que imagino a C# y Java, junto con lenguajes WEB...
Y alguien que sepa mas que yo: ¿Python, qué futuro tiene? ¿Incierto o tiene un futuro exitoso? Se la potencia, alcanze y posiblidad que da Python, pero también se que Java está respaldada por SUN MS, .net por Microsoft, y que eso ayuda a definir el futuro de los lenguajes.
Leí en Google, muchos foros, y demás, algunos eran temas muy viejos, otros no me parecieron convicentes. ¿Me podrían dar una mano? Desde ya, es pura intriga, y ganas de conocer. Python me parece un exelente lenguaje, y lo voy a seguir aprendiendo independientemente del futuro que tenga. Sólamente desearía tener una idea.
  Muchas gracias de antemano. Saludos.

 Estoy intentando hacer una función en la cuál se le pasa una cadena como parámetro, y obtiene el valor numérico de cada carácter, y los suma todos. Intenté con for y while, pero no le encuentro la vuelta. Alguien me podría decir si hay una función que haga esto?
         
edit: Que idiotez la mía olvidé decir que trabajo en Python.

Qué tal gente, espero que me puedan ayudar. Leyendo en la documentación de Python no encontré módulo alguno que capture las teclas (Se que hay pero no son oficiales). ¿Hay alguna forma de poder capturar teclas sin bajar ningún módulo ni nada? Sólamente por curiosidad. No hace falta que me den links directos ni nada, nada mas díganme si lo hay, porque la verdad no lo encuentro u.u

Busqué si hay algo estándar de PYthon, pero no encuentro. Si se que está termcolor, pero no me funciona en Windows... ¿Tengo que hacerlo por mi mismo? ¿De qué tengo que informarme? Es que quiero darle algo mas de vida a la consola.
Muchas gracias de antemano.ç

EDIT:
Ahora encontré una WEB que no me cargaba, habla sobre ctypes. Y da ejemplo de cambio de color. Por lo que veo llama a las APIs de Windows... Me imagino que con esto me va a ser suficiente... Igual, si me pueden orientar un poco mas lo agradecería...

EDIT2:
Acá logré avanzar algo, mirando este código:

Código [Seleccionar] Expandir

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

FOREGROUND_BLUE = 0x01 # text color contains blue.
FOREGROUND_GREEN= 0x02 # text color contains green.
FOREGROUND_RED  = 0x04 # text color contains red.
FOREGROUND_INTENSITY = 0x08 # text color is intensified.
BACKGROUND_BLUE = 0x10 # background color contains blue.
BACKGROUND_GREEN= 0x20 # background color contains green.
BACKGROUND_RED  = 0x40 # background color contains red.
BACKGROUND_INTENSITY = 0x80 # background color is intensified.

import ctypes

std_out_handle = ctypes.windll.kernel32.GetStdHandle(STD_OUTPUT_HANDLE)

def set_color(color, handle=std_out_handle):
   """(color) -> BOOL
   
   Example: set_color(FOREGROUND_GREEN | FOREGROUND_INTENSITY)
   """
   bool = ctypes.windll.kernel32.SetConsoleTextAttribute(handle, color)
   return bool

Aunque no logro entenderlo, qué hacen exactamente las variables STD_OUTPUT_HANDLE y demás? Se que las otras son para colores, y después por lo visto ctypes.windll.kernel32 es para acceder a una función del kernel32. el identificador 'bool' es obligatorio? Ahora voy a averiguar sobre GetStdHandle, a ver si logro entenderlo u.u

Alguien que sepa sobre lo de las teclas? n.n

EDIT (numero 500millones): El tema de los códigos hexadecimales, cada dígito hexadecimal corresponde a un número y a un fondo? O 2 dígitos hexadecimales tienen un estándar?
Según el código, 0x80 intensifica el fondo, pero pruebo y no logro entender que es lo que realmente hace. :\

 Qué tal gente? Estaba INTENTANDO hacer un programa que muestre "hola mundo", y en la línea siguiente que muestre "presione una tecla para continuar", y espere que se ingrese una tecla. Inicialmente había hecho esto

Código [Seleccionar] Expandir

org 100h
use16

MOV      AH,9
MOV      DX,Texto
INT       21h             ;Muestro "Hola mundo!"
MOV      DX,Pausa
INT        21H            ;Muestro "Presione una tecla para continuar"
MOV      AH,1            ;Espero el ingreso de una tecla
INT        21H
INT        20h

Texto db 'Hola mundo!', 24h
Pausa db 'Presione una tecla para continuar.', 24h

Ahora, el mensaje "Presione una tecla para continuar" me aparece pegado al texto. La idea era que me quedara en la línea de abajo. Así que conté la cantidad de carácteresde "Hola mundo!", y la reste a la cantidad de columnas. Me dió 74, así que quise poner 74 espacios después del "Hola mundo!" asi el mensaje de pausa aparecía en la línea de abajo, intenté:

Código [Seleccionar] Expandir


org 100h
use16

MOV      DX,Texto
MOV      AH,9
INT        21H
JMP        Espacios

Espacios:
MOV     DX,Espacio
MOV     CX,4A
INT       21h
DEC      CX
LOOP     Espacios
JMP       Pausa

Pausa:
MOV     AH,1
INT      21h
INT      20h



O sea, la idea es que inicie CX en 74, y vaya decrementando, y por cada ciclo, agregue un espacio. Al llegar a los 74, saltaría a la segunda línea y mostraría eso
(SI, soy un asco para esto)
La cosa es que tampoco me funciona así. Me estoy guiando por manuales viejos les aviso n.n

Y también vi algo de "salto de línea" que tenía que ponerle 0D 0A al final del texto del que saltaría a la otra línea, y me tira sintáxis inválida

Si alguien me puede decir como hacer funcionar eso, lo agradecería u.u

 De nuevo yo con mis problemas raros, estoy usando IDLE, estaba probando el siguiente código (Da las raíces de una ecuación cuadrática, y muestra los pasos para hacerla), y realmente, andaba todo bien, iba editando la funcion LinealStep (Que en el código se ocupa de mostrar el paso por paso), y de repente el programa empezó a tirar "Syntax Error", en algo donde no había tocado absolutamente nada. Me marca "def". Y me marca siempre uno. No sé sinceramente cuál es el error sintáctico acá. Se que no tiene que ver con identación (O al menos no me dice eso):

Código [Seleccionar] Expandir

# -*- coding: cp1252 -*-

from os import system
from cmath import sqrt

def Lineal(a, b, c):
       a               = float(a)
       b               = float(b)
       c               = float(c)
       bc              = b ** 2.0
       bcstr           = str(bc)
       
       Disc            = bc - 4.0 * a * c
       DiscStr         = str(Disc)
       DiscStr2        = 'bc - 4.0 * a * c'
       
       Sqr_Res         = sqrt(Disc)
       Sqr_ResStr      = str(Sqr_Res)
       Sqr_ResStr2     = 'R2(bc - 4.0 * a * c)'
       
       NEG_Res         = -b - Sqr_Res / (2.0 * a)
       rNEG_Res        = abs(NEG_Res)
       
       POS_Res         = -b + Sqr_Res / (2.0 * a)
       rPOS_Res        = abs(POS_Res)
       
       print ' '
       print 'Fórmula usada: -b +- R2 <b^2 - 4 * a * c>'
       print '                        -----------------'
       print '                             2 * a      '

       LinealStep(a, b, c, bc, bcstr, Sqr_Res)

       print 'X1 = ', rPOS_Res
       print 'X2 = ', rNEG_Res

def LinealStep(a, b, c, bc, bcstr, Sqr_Res):

       Astr, Bstr, Cstr, BCstr = str(a), str(b), str(c), str(bc)
       print 'Paso 1) Implementar fórmula'
       print 'Paso 2) Reemplazar:'
       print ' a por ', Astr
       print ' b por ', Bstr
       print ' c por ', Cstr

       print 'Quedando asi la formula: ', Bstr, ' +- R2<', Bstr, '^2 + 4 * ', Astr, ' * ', Cstr, '>'
       print ' '* 36, '-' * 25
       print ' '* 45, '2 * ', Astr

       print 'Resolviendo interior de la raiz(Discriminante): '
       print ' ', Bstr, '^2 + 4 * ', Astr, ' * ', Cstr
       print ' ', BCstr, ' + ', str((4 * a) * c)
       print ' ', str(bc + (4 * a) * c), ' '

       print 'Ahora, se calcula la raiz cuadrada de ', str(bc + (4 * a) * c)
       print 'R2<', str(bc + (4 * a) * c, ' = ', Sqr_Res

##ACÁ ME TIRA ERROR MARCANDO "def", pero a veces lo marca en los otros def
def Menu():
       TCuad           = raw_input('Coeficiente de termino cuadratico(a): ')
       TX              = raw_input('Segundo coeficiente(b): ')
       TIndep          = raw_input('Término independiente(c): ')
       print           'La ecuacion quedaria de la siguiente manera: '
       print           int(TCuad), 'X^2 + ', int(TX), 'X + ', int(TIndep)
       Next            = raw_input('Presione enter para hallar raíces: ')
       Lineal(TCuad, TX, TIndep)

Menu()


EDIT: Y ahora, saqué la función Menu, y me marca error en el nombre de la variable TCuad, dejo el código de esa última parte:

Código [Seleccionar] Expandir

def LinealStep(a, b, c, bc, bcstr, Sqr_Res):

        Astr, Bstr, Cstr, BCstr = str(a), str(b), str(c), str(bc)
        print 'Paso 1) Implementar fórmula'
        print 'Paso 2) Reemplazar:'
        print ' a por ', Astr
        print ' b por ', Bstr
        print ' c por ', Cstr

        print 'Quedando asi la formula: ', Bstr, ' +- R2<', Bstr, '^2 + 4 * ', Astr, ' * ', Cstr, '>'
        print ' '* 36, '-' * 25
        print ' '* 45, '2 * ', Astr

        print 'Resolviendo interior de la raiz(Discriminante): '
        print ' ', Bstr, '^2 + 4 * ', Astr, ' * ', Cstr
        print ' ', BCstr, ' + ', str((4 * a) * c)
        print ' ', str(bc + (4 * a) * c), ' '

        print 'Ahora, se calcula la raiz cuadrada de ', str(bc + (4 * a) * c)
        print 'R2<', str(bc + (4 * a) * c, ' = ', Sqr_Res


TCuad           = raw_input('Coeficiente de termino cuadratico(a): ')
TX              = raw_input('Segundo coeficiente(b): ')
TIndep          = raw_input('Término independiente(c): ')
print           'La ecuacion quedaria de la siguiente manera: '
print           int(TCuad), 'X^2 + ', int(TX), 'X + ', int(TIndep)
Next            = raw_input('Presione enter para hallar raíces: ')
Lineal(TCuad, TX, TIndep)

Me marca en rojo TCuad.  Qué onda? O sea, no hay problemas de identación, no es palabra reservada, y me anduvo perfecto :\ se me empezó a buguear con el def de las funciones, saco la función Menu y me tira error en eso u.u


Desde ya muchas gracias de antemano n.n

 O hay algo que estoy pasando por alto, o algo funca mal, me tira "IdentationError: Unindent doesnt match any outer identation level", es decir, que no encaja con ningún otro nivel de identación. Estoy pensando que es algún tipo de problema con el editor de texto, verán acá si les pongo el código me aparecen las cosas con una identación DIFERENTE a la que veo yo en mi editor (notepad++), según donde lo veo, está todo identado como se debe. Les dejo el código, el txt y la imágen de como lo veo yo.
EDIT: El error está en la línea 59, pero miren la imágen porque el código está mal identado, no es como lo tengo yo en m txt.
Código:

Código [Seleccionar] Expandir


import marqlib
from random import randint

RondasJugadas = 0
PCGanadas = 0
UsuariosGanadas = 0
gDTj = '>8'
gITj = '8<'
gPr = '[]'
gPl = '#'

def Clean():
   system('cls')

def Tabla(uGanadas, pGanadas, rJugadas, uObjeto, pObjeto):
   print 'Rondas jugadas: ', rJugadas
   print 'Usuario: (', uObjeto, '): ', uGanadas
   print 'PC: (', pObjeto, '): ', pGanadas
   Next = raw_input()
   Clean()
 
def Presentacion():
   system('color 1f & cls')
   marqlib.DAI_Marq(' ', 'Piedra, Papel, O Tijera!', 25, 1, 1, 0.1)

def EleccionPC():
   ePC = randint(1, 3)
   return ePC

def Rest(Val, PCGanadas, UsuarioGanadas, RondasJugadas, PC_Objeto, Usuario_Objeto):
  if Val == 0:
     print 'Empate!'
     Tabla(UsuarioGanadas, PCGanadas, RondasJugadas, pObjeto, uObjeto)
  elif Val == 1:
      Tabla(UsuarioGanadas, PCGanadas, RondasJugadas, pObjeto, uObjeto)
  elif Val == 3:
      print 'Ganador: USUARIO!'
      Tabla(UsuarioGanadas, PCGanadas, RondasJugadas, Usuario_Objeto, PC_Objeto)
  elif Val == 4:
      print 'Ganador: PC'
      Tabla(UsuarioGanadas, PCGanadas, RondasJugadas, Usuario_Objeto, PC_Objeto)

def Jugada(Usuario_Objeto, Usuario_Opcion, PC_Opcion, PC_Objeto):
 while PCGanadas <= 2 or UsuarioGanadas <= 2:
   RondasJugadas += 1
   if Usuario_Opcion == PC_Opcion:
    Rest(0, PCGanadas, UsuarioGanadas, RondasJugadas, PC_Objeto, Usuario_Objeto)
   elif Usuario_Opcion == 1 and PC_Opcion == 2:
    PCGanadas += 1
    Rest(1, PCGanadas, UsuarioGanadas, RondasJugadas, PC_Objeto, Usuario_Objeto)
   elif Usuario_Opcion == 1 and PC_Opcion == 3:
    UsuarioGanadas += 1
    Rest(1, PCGanadas, UsuarioGanadas, RondasJugadas, PC_Objeto, Usuario_Objeto)
   elif Usuario_Opcion == 2 and PC_Opcion == 1:
    UsuarioGanadas += 1
    Rest(1, PCGanadas, UsuarioGanadas, RondasJugadas, PC_Objeto, Usuario_Objeto)
   elif Usuario_Opcion == 2 and PC_Opcion == 3:
    PCGanadas += 1 #LA LINEA QUE SIGUE ES LA 59.
        Rest(1, PCGanadas, UsuarioGanadas, RondasJugadas, PC_Objeto, Usuario_Objeto)
   elif Usuario_Opcion == 3 and PC_Opcion == 2:
    UsuarioGanadas += 1
        Rest(1, PCGanadas, UsuarioGanadas, RondasJugadas, PC_Objeto, Usuario_Objeto)
   elif Usuario_Opcion == 3 and PC_Opcion == 1:
    PCGanadas += 1
    Rest(1, PCGanadas, UsuarioGanadas, RondasJugadas, PC_Objeto, Usuario_Objeto)
 if PCGanadas == 2:
   Rest(4, PCGanadas, UsuarioGanadas, RondasJugadas, PC_Objeto, Usuario_Objeto)
MenuDeJuego()
 elif UsuarioGanadas == 2:
   Rest(3, PCGanadas, UsuarioGanadas, RondasJugadas, PC_Objeto, Usuario_Objeto)
   MenuDeJuego()

def MenuDeJuego():
   PCOp = EleccionPC()
   mOp = raw_input('Piedra(1), Papel(2), o Tijera(3)? ')
   if PCOp == 1:
       Obj = gPr
   elif PCOp == 2:
       Obj = gPl
   elif PCOp == 3:
       Obj = gDTj
   OpcionUsuario(mOp, PCOp, Obj)

def OpcionUsuario(Opcion, PCOp, Obj):
   if Opcion > 3:
       print 'Error. Opcion incorrecta'
   break
   if Opcion == 1:
       ObjetoElegido = gPr
   Jugada(ObjetoElegido, Opcion, PCOp, Obj)
   elif Opcion == 2:
       ObjetoElegido = gPl
   Jugada(ObjetoElegido, Opcion, PCOp, Obj)
   elif Opcion == 3:
       ObjetoElegido = gITj
       Jugada(ObjetoElegido, Opcion, PCOp, Obj)

Presentacion()
MenuDeJuego()

Ven ahí que la línea 59 (precedida por mi comentario en el código) se ve con otra identación, errónea según mi entender. Pero yo en mi editor de texto la veo de la siguiente manera:
http://imageshack.us/photo/my-images/807/asden.jpg/

Fíjense que la línea 59 está identada tal cual como las anteriores, y el error sale justo en esa línea, y en caso de que la identación esté mal, por qué no salió en las anteriores si están identadas de la misma forma? :\

Sinceramente no veo porque el error está en esa línea que es igual a las otras.
Gracias de antemano por la ayuda Por si influye en algo, uso Python2.7.

Saludos, y gracias por cualquier ayuda n.n

PD: El código subido acá no está identado de la misma forma que en mi editor de textos, asi que es mejor guiarse por la imágen :S

Tengo una duda, no logro entender esto:
Yo para usar ASM en WinXP, SI O SI tengo que usar ASM de 32bits (eso de modo protegido) sin interrupciones y eso? O puedo usar ASM 16bits en modo real?
En caso de poder usar 16bits, se pueden crear con MASM? O tengo que usar otro?
Leí, y me bajé el TASM jajaj, es viejo pero bueno estoy intentando aprender

Simplemente, leyendo un manual, y practicando de todas las maneras que se me ocurren, NO me sale un programa tan básico como este (El objetivo es pedir un nombre, un edad y mostrarlas. si, no tiene sentido, pero es para practicar). La idea es que para mostrarlos, llame a una funcion, y la idea es que lo haga 10 veces xD. En fin, me tira 500mil errores, y no llego a entender dónde me equivoco. Es mi primer programa que hago, asi que es un desastre seguramente, no se suiciden al verlo ni me insulten jaja.

#include <iostream.h>

char Nombre[30],RetornoMD;
char Edad[2];

void MostrarDatos(char N, int E);


int main() {
   //Pedir nombre
   cout << "Ingrese nombre su nombre: " <<endl;
   cin >>Nombre;
   cout << "Ingrese su edad: " << endl;
   cin >> Edad;
     for (int count = 1; count = 10; count = i++);
     MostrarDatos(Nombre, Edad);
   return 0;
}

void MostrarDatos(char N, char E) {
    cout << "Su nombre es: " << N << endl;
    cout << "Usted tiene " << E << " años" << endl;
     }

Desde ya ES UN DESASTRE, pero es lo que intento. Y otra cosa, si la función es void, no tengo que poner el return, no?xD

Tengo 500mil errores, pero bueno n.n espero que un alma generosa me diga algún consejito n.n

Gracias de antemano n.n un abrazo.

USO DEV-C++

De nuevo yo con mis inquietudes...

Es posible (Usando FASM), programar una aplicación de Consola?
Se puede usar interrupciones en FASM? Digamos, (Seguramente hablo guasadas para ustedes que la tienen mas clara que yo), puedo en vez de programar para 32bits usando APIS, usar en modo 16bits usando interrupciones o demás?


Y otro tema, (que hize en otro TH).
En ASM de 16bits, para crear un archivo tengo que hacer lo siguiente:

Poner 3C en AX
Poner en DS:DX el sector que contiene la cadena en ASCII de la ruta del archivo
Poner en CX los atributos del archivo
INT 21
Ahora bien, haciéndolo dede debug da:

-a100
jmp 125

-e 102 'RutaArchivo' 0a 0d '$'
-a125
MOV DX,0102
MOV CX,00
MOV AX,3C
INT 21H
INT 20H

Bueno, genero el .com y todo, y cuando lo ejecuto, no me crea el archivo. Estuve leyendo, y puede ser que tenga que ver con "modo protegido vs modo real"?

Ténganme paciencia, estoy dando los primeros pasos.

También, quiero que borren mi otro TH, ya que planteo una duda parecida acá. El TH es "Dudas asm 16bits".

Disculpen mi infinita ignorancia respecto a esto, y de antemano, mil gracias por la ayuda.

 Hola, que tal. Bueno, yo hace un bueeeen tiempo que vengo ojeando esta comunidad, y intenté registrarme hace tiempo con mi otro mail, y no me llegó nunca el correo de confirmación Con mail nuevo, estreno cuenta y dudas =)

Estoy leyendo muuuchos manuales, tutoriales, FAQs, para esclarecer varios conceptos.
1-) Qué es una pila? No logro entender qué es.
2-) Registros de segmentos. Tengo esta explicacion sacada de una WEB.
Un registro de segmento se utiliza para alinear en un limite de párrafo o dicho de otra forma codifica la dirección de inicio de cada segmento y su dirección en un registro de segmento supone cuatro bits 0 a su derecha.
Un registro de segmento tiene 16 bits de longitud y facilita un área de memoria para direccionamientos conocidos como el segmento actual. Los registros de segmento son:
    * Registro CS
    * Registro DS
    * Registro SS
    * Registro ES
    * Registro FS y GS

En el debug, me aparece por ejemplo
151D:0100, 151D es el segmento y 0100 la dirección? Ahora, no entiendo la explicación, que quiere decir "alinear en un límite de párrafo" y no entiendo la utilidad del registro de segmento :S

3-) Un Desplazamiento es.....? De lo poco que entendí, es que por ejemplo, en 151D:0100 el desplazamiento es 0100 :\ Y seguro debe estar mal.

4-) Qué es un segmento de código?

Espero puedan ayudarme
Un abrazo, atte.