Exemplo de ASP: produção de jogos de combinação de palavras

＜%@ idioma = VBScript%＞

＜%

Opção explícita

Última atualização por Recon em 16/03/2001

Dim M_ipartcnt

Dim M_STRPROMPT

Dim M_ASTRSENPART (), M_ASTRFILENAME ()

Dim m_astrwords (), m_aiopstatus ()

'--------------------------------------------

'Descrição variável constante

'M_IPARTCNT: Número de categorias de vocabulário. Inteiro

'm_strprompt: um prompt após a conclusão da operação do arquivo. Tipo de string

'M_ASTRSENPART: o nome da classificação do vocabulário. Array do personagem

'M_ASTRFILENAME: registra os nomes de arquivos de vários arquivos de vocabulário. Array do personagem

'M_ASTRWORDS: grave todos os tipos de vocabulário. Array de caracteres bidimensional

'M_AIOPSTATUS: registra o status após operar em cada arquivo. Matriz inteira

'--------------------------------------------

ShowMethod

m_ipartcnt = 4

m_strprompt =

Redim M_ASTRSENPART (M_IPARTCNT)

Redim m_astrfilename (m_ipartcnt)

Redim m_astrwords (m_ipartcnt)

Redim m_aiopstatus (m_ipartcnt)

'Defina os nomes de várias categorias de vocabulário

M_ASTRSENPART (0) = sujeito

m_astrsenPart (1) = grau adverbial

m_astrsenPart (2) = local adverbial

m_astrSenPart (3) = predicado

'Defina os nomes de vários documentos de vocabulário

m_astrfilename (0) = who.txt

m_astrfilename (1) = How.txt

m_astrfilename (2) = where.txt

m_astrfilename (3) = o quê.txt

Se request.Servervariables (request_method) = postar então

'Se o método de solicitação da página for postagem

'***************************

'Obtenha informações do cliente

'***************************

Dim M_isenPart

Dim M_Stropway

Dim M_BRPTEDDATA

'--------------------------------------------

'Descrição variável constante

'M_isenPart: números que representam a classificação do vocabulário. Inteiro

'A classificação do vocabulário vem da matriz M_ASTSENPART

'Valores possíveis são:

'0: Assunto

'1: grau adverbial

'2: Lugar Adverbial

'3: predicado

'M_STROPWAY: Método de operação de arquivo. Tipo de string

'Valores possíveis são:

'1. Salvar: salve um certo tipo de vocabulário em um arquivo

'2. SaveAll: salve todas as categorias de vocabulário em um arquivo

'3. Carregar: Carregue um certo tipo de vocabulário do arquivo

'4. Loadall: carregue todas as categorias de vocabulário do arquivo

'm_brptedData: indica se os dados do formulário enviados desta vez são os mesmos da última vez. Tipo booleano

'Valores possíveis são:

'1. Falso: os dados do formulário não são duplicados

'2. Verdadeiro: os dados do formulário são repetidos (ou seja, o formulário é enviado repetidamente)

'--------------------------------------------

'ShowForm

'Como obter solicitações de usuário

m_stropway = request.form (txtopway)

'Show (m_stropway)

'Obtenha palavras em várias categorias

Para m_icount = 0 a (m_ipartcnt - 1)

Se request.form (txtwords & m_icount) ＜＞ então

m_astrwords (m_icount) = split (request.form (txtwords & m_icount) ,,)

Final se

'Response.Write Ubound (m_astrwords (m_icount)) & ＜br>

Próximo

'Detecção de envio repetido de formulários

'Se sessão (formInf) = request.form então

'' O formulário é um envio repetido

'm_brptedData = true

'Outro

'' O formulário é uma submissão não repetida

'Session (forminf) = request.form

'm_brptedData = false

'Final se

'Show (m_brptedData)

'***************************

'Opere o arquivo do Word

'***************************

'Se m_brptedData = false então

Dim m_icount, m_ierrcnt

Dim m_strfilepath

'--------------------------------------------

'Descrição variável constante

'm_icount: contador. Inteiro

'm_ierrcnt: o número de vezes a operação falhou. Inteiro

'M_STRFILEPATH: Registre o caminho de vários arquivos de vocabulário. Tipo de string

'--------------------------------------------

'Pegue o caminho para colocar o arquivo de vocabulário

m_strfilepath = request.Servervariables (PATH_TRANSLATED)

m_strfilepath = esquerda (m_strfilepath, instrumv (m_strfilepath, /))

'm_strfilepath = m_strfilepath & words/

'Show (m_strfilepath)

'Inicie a operação do arquivo

'Response.Write Beg comece a operar arquivos de palavras <br>

Selecione o caso M_Stropway

Salvar casos

'Salvar palavras para arquivar

m_isenPart = cint (request.form (txtSenPart))

M_AIOPSTATUS (M_ISENPART) = SAVEFILE (M_ISENPART)

'De acordo com o status da operação, obtenha as informações rápidas

Selecione o caso M_AIOPSTATUS (M_ISENPART)

Caso 0

M_STRPROMPT = [& M_ASTSENPART (M_ISENPART) &] Algumas palavras foram salvas com sucesso no arquivo

Caso 1

M_STRPROMPT = [& M_ASTSENPART (M_ISENPART) &] Salvando alguns arquivos falhados

Final Selecione

Case SaveAll

'Salve todas as categorias de palavras no arquivo

m_ierrcnt = 0

Para m_icount = 0 a (m_ipartcnt - 1)

M_AIOPSTATUS (M_ICOUNT) = SAVEFILE (M_ICOUNT)

Se m_aiopstatus (m_icount) = 1 então

m_ierrcnt = m_ierrcnt 1

Final se

Próximo

'De acordo com o status da operação, obtenha as informações rápidas

Selecione o caso m_ierrcnt

Caso 0

m_strprompt = todas as categorias de palavras foram salvas com sucesso no arquivo

Caso m_ipartCNT

m_strprompt = arquivos do Word em todas as categorias falhou em salvar

Caso mais

m_strprompt = onde,

Para m_icount = 0 a (m_ipartcnt - 1)

Se m_aiopstatus (m_icount) = 1 então

m_strprompt = m_strprompt & [& m_astrSenPart (m_icount) &],

Final se

Próximo

m_strprompt = esquerda (m_strprompt, len (m_strprompt) - 1)

m_strprompt = m_strprompt e alguns arquivos falharam em salvar

Final Selecione

Carga de caixa

'Carregue palavras do arquivo

m_isenPart = cint (request.form (txtSenPart))

M_AIOPSTATUS (M_ISENPART) = LOADFILE (M_ISENPART)

'De acordo com o status da operação, obtenha as informações rápidas

Selecione o caso M_AIOPSTATUS (M_ISENPART)

Caso 0

m_strprompt = [& m_astrsenPart (m_isenPart) &] Algumas palavras foram carregadas com sucesso

Caso 1

M_STRPROMPT = [& M_ASTSENPART (M_ISENPART) &] Alguns arquivos não existem e o carregamento falha

Final Selecione

Case Loadall

'Carregue palavras de cada arquivo

m_ierrcnt = 0

Para m_icount = 0 a (m_ipartcnt - 1)

M_AIOPSTATUS (m_icount) = loadfile (m_icount)

Se m_aiopstatus (m_icount) = 1 então

m_ierrcnt = m_ierrcnt 1

Final se

Próximo

'De acordo com o status da operação, obtenha as informações rápidas

Selecione o caso m_ierrcnt

Caso 0

m_strprompt = todas as categorias de palavras foram carregadas com sucesso

Caso m_ipartCNT

m_strprompt = arquivos do Word em todas as categorias não existem, o carregamento falha completamente

Caso mais

m_strprompt = onde,

Para m_icount = 0 a (m_ipartcnt - 1)

Se m_aiopstatus (m_icount) = 1 então

m_strprompt = m_strprompt & [& m_astrSenPart (m_icount) &],

Final se

Próximo

m_strprompt = esquerda (m_strprompt, len (m_strprompt) - 1)

m_strprompt = m_strprompt e alguns arquivos não existem, algumas falhas de carregamento

Final Selecione

Final Selecione

'Final se

Final se

'Response.Write final para operar arquivos de palavras <br>

'Response.Write Beg comece a escrever a página do cliente <br>

%＞

＜ Html ＞

＜ Cabeça ＞

＜ Título ＞ jogo de correspondência de palavras ＜/título ＞

＜ Meta nome = conteúdo do gerador = editplus ＞

＜ Meta nome = conteúdo do autor =>

＜ Meta Nome = Palavras -chave Content =>

＜ Meta Nome = Descrição Content =>

＜!-Tabela de estilo->

＜ Estilo>

＜!-

/*Fonte inglesa 1*/

.Fonteng1

{

Fonte-família: Times New Roman;

estilo de fonte :;

}

/*Fonte inglesa 2*/

.Fonteng2

{

Fonte-família: Times New Roman;

estilo de fonte: itálico;

}

/*Aderir à fonte*/

.FONTEMP

{

Cor: vermelho;

}

/*Link*/

.link

{

Fonte-família: Times New Roman;

estilo de fonte: itálico;

Decoração de texto: Nenhum;

}

/* Lista de palavras exibidas*/

.Listshown

{

Posição: Absoluto;

Largura: 140px;

Altura: 200px;

exibição: embutido;

Fronteira: Lightcoral 1px sólido;

Background-Color: Gainsboro;

}

/*Lista de palavras ocultas*/

.Listhdiddden

{

Posição: Absoluto;

Largura: 140px;

Altura: 200px;

Exibir: Nenhum;

Fronteira: Lightcoral 1px sólido;

Background-Color: Gainsboro;

}

/*Lista de palavras fixa*/

.Listfixed

{

Posição: Absoluto;

Largura: 140px;

Altura: 200px;

exibição: embutido;

borda: vermelho 1px sólido;

Background-Color: Gainsboro;

}

/*Mostrou lista de ajuda*/

.HelPShown

{

Posição: Absoluto;

largura: ;

altura: ;

exibição: bloco;

Fronteira: Lightcoral 1px sólido;

Background-Color: Gainsboro;

}

/*Lista de ajuda oculta*/

.Helphidden

{

Posição: Absoluto;

largura: ;

altura: ;

Exibir: Nenhum;

Fronteira: Lightcoral 1px sólido;

Background-Color: Gainsboro;

}

/*Lista de ajuda fixada*/

.Helpfixed

{

Posição: Absoluto;

largura: ;

altura: ;

exibição: bloco;

borda: vermelho 1px sólido;

Background-Color: Gainsboro;

}

/*Tags destacadas*/

.lblMover

{

Decoração de texto: Nenhum;

Cor: Lightcoral;

cor de fundo :;

}

/*Tag de exibição normal*/

.lblmout

{

Decoração de texto: Nenhum;

cor: ;

cor de fundo :;

}

/*Tag clicada*/

.LblClicked

{

Decoração de texto: sublinhado;

Cor: vermelho;

cor de fundo :;

}

/* Botão destacado*/

.BtnLighted

{

Largura: 105px;

Cor: azul;

cor de fundo :;

}

/*Botão de exibição comum*/

.BtndElfelfled

{

Largura: 105px;

cor: ;

cor de fundo :;

}

/* Item da lista de palavras destacada*/

.opthighted

{

Decoração de texto: sublinhado;

Cor: azul;

cor de fundo :;

Cursor: mão;

}

/*Item da lista de palavras exibidas Normal*/

.optdelfleoted

{

Decoração de texto: Nenhum;

cor: ;

cor de fundo :;

Cursor :;

}

->

＜/estilo>

＜!-Script do cliente->

＜ Idioma do script = JavaScript>

＜!-

// Funções públicas e de teste do cliente

// *****************************************

// Nome da função: ltrim

// função: remova o espaço no lado esquerdo da corda

// entrada: 1. Strtemp: a string a ser regular. Tipo de string

// Saída: string regular. Tipo de string

// *****************************************

função ltrim (strtemp)

{

var iCount, iLength;

// ----------------------------------------------

// Descrição da variável constante

// ICOUNT: contador. Inteiro

// iLength: o comprimento da corda. Inteiro

// ----------------------------------------------

iLength = strTemp.Length;

para (ICOUNT = 0; ICOUNT ＜ ILENDO; ICOUNT)

if (strtemp.charat (iCount)! =)

return strtemp.substring (iCount, iLength);

retornar ;

}

// *****************************************

// Nome da função: rtrim

// função: remova o espaço no lado direito da corda

// entrada: 1. Strtemp: a string a ser regular. Tipo de string

// Saída: string regular. Tipo de string

// *****************************************

função rtrim (strtemp)

{

var iCount, iLength;

// ----------------------------------------------

// Descrição da variável constante

// ICOUNT: contador. Inteiro

// iLength: o comprimento da corda. Inteiro

// ----------------------------------------------

iLength = strTemp.Length;

for (ICOUNT = ILENGLE -1; ICOUNT> = 0; ICOUNT -)

if (strtemp.charat (iCount)! =)

return strtemp.substring (0, ICOUNT 1);

retornar ;

}

// *****************************************

// Nome da função: TRIM

// função: remova os espaços em ambos os lados da corda

// entrada: 1. Strtemp: a string a ser regular. Tipo de string

// Saída: string regular. Tipo de string

// *****************************************

Função de acabamento (strtemp)

{

retornar rtrim (lTRIM (strTemp));

}

// converte números de 2 dígitos em string de 2 dígitos

// *****************************************

// Nome da função: get2bnumstr

// Função: converta números de 2 bits em string de números de 2 bits

// entrada: 1. Inumber: o número a ser convertido. Inteiro

// Saída: a sequência numérica convertida. Inteiro

// *****************************************

função get2bnumstr (inumber)

{

var str2bnum;

// ----------------------------------------------

// Descrição da variável constante

// str2bnum: string numérica. Tipo de string

// ----------------------------------------------

if (parseint (inumber) ＜ 10)

str2bnum = 0 inumber;

outro

str2bnum = inumber;

retornar STR2bnum;

}

// *****************************************

// Função func Nome: Atributefunc

// função: especifique a função de manuseio de eventos do elemento

// Entrada: 1. ELE: O elemento da função de manuseio de eventos a ser especificado. Tipo de objeto

// 2. Func: Função de manuseio de eventos. Funcional

// 3. Evento: Tipo de evento. Tipo de string

// Saída: Nenhum

// *****************************************

Função Atribuindo (ele, func, evento)

{

var iCount, ieleCount;

Var Strevent;

// ----------------------------------------------

// Descrição da variável constante

// ICOUNT: contador. Inteiro

// ieleCount: o número de elementos na coleção de elementos com o mesmo nome. Inteiro

// strevent: tipo de evento. Tipo de string

// ----------------------------------------------

if (event == null)

Strevent = OnClick;

outro

strevent = evento;

ieleCount = ele.length;

if (ieleCount == indefinido)

Eval (ele. Strevent = func);

outro

para (ICOUNT = 0; ICOUNT ＜ IELECOUNT; ICOUNT)

Eval (ELE [ICOUNT]. Strevent = func);

}

// *****************************************

// Nome da função: getEleIndex

// função: obtenha o índice do elemento em que o evento ocorreu na coleção de mesmo nome

// Entrada: 1. ELESRC: O elemento onde o evento ocorreu. Tipo de objeto

// Saída: índice do elemento em que o evento ocorreu na coleção de mesmo nome

// *****************************************

function geteleIndex (ELESRC)

{

var colsrc;

var iCount, ieleCount;

// ----------------------------------------------

// Descrição da variável constante

// colsrc: coleção de elementos com o mesmo nome. Array do tipo objeto

// ICOUNT: contador. Inteiro

// ieleCount: o número de elementos na coleção de elementos com o mesmo nome. Inteiro

// ----------------------------------------------

colsrc = Eval (Elesrc.id);

ieleCount = colsrc.length;

para (ICOUNT = 0; ICOUNT ＜ IELECOUNT; ICOUNT)

{

if (colsrc [iCount] == ​​ELESRC)

retornar o ICOUNT;

}

retornar -1;

}

// mostra o valor da variável constante (para depuração)

//! Prepare -se para excluir

Função mostra (STRDEF1, STRDEF2, STRDEF3, STRDEF4)

{

var iCount, idefcnt;

var strshow, strtemp;

idefcnt = 4;

strshow = [valor variável constante];

para (ICOUNT = 1; ICOUNT ＜ = IDEFCNT; ICOUNT)

{

strTemp = Eval (strDef ICount);

if (strtemp! = indefinido && strtemp! = null)

strshow = /n strtemp: avaliar (strtemp);

}

alerta (strshow);

}

// *****************************************

// Nome da função: ShowArray

// Função: Exibir elementos da matriz unidimensional (para depuração)

// Entrada: 1. Array: a matriz unidimensional a ser exibida. Variedade

// Saída: Nenhum

// *****************************************

Função ShowArray (Array)

{

var iCount, ieleCount;

var strshow;

// ----------------------------------------------

// Descrição da variável constante

// ICOUNT: contador. Inteiro

// ieleCount: o número de elementos da matriz. Inteiro

// strshow: uma string composta por valores de elemento da matriz. Tipo de string

// ----------------------------------------------

ieleCount = array.length;

strshow = comprimento da matriz: ieleCount;

strshow = /n ----------------------------------- /n;

para (ICOUNT = 0; ICOUNT ＜ IELECOUNT; ICOUNT)

{

if (typeof (array [iCount]) == objeto)

strshow = matriz [ICOUNT] .ID;

outro

strshow = matriz [ICOUNT];

}

alerta (strshow);

}

// *****************************************

// Nome da função: SHOW2DARRAY

// Função: Exibir elementos de uma matriz bidimensional (para depuração)

// entrada: 1. Array: a matriz bidimensional a ser exibida. Variedade

// Saída: Nenhum

// *****************************************

Função Show2Darray (Array)

{

var ix, iy, ilen1, ilen2;

var strshow;

// ----------------------------------------------

// Descrição da variável constante

// ix: contador. Inteiro

// iy: contador. Inteiro

// ILEN1: O número de matriz unidimensional. Inteiro

// ILEN2: O número de matrizes bidimensionais. Inteiro

// strshow: uma string composta por valores de elemento da matriz. Tipo de string

// ----------------------------------------------

ilen1 = array.length;

strshow = matriz 1d Comprimento: ILEN1;

strshow = /n ---------------------------------;

para (ix = 0; ix ＜ ilen1; ix)

{

strshow = /n;

ilen2 = matriz [ix] .Length;

para (iy = 0; iy ＜ ilen2; iy)

strshow = matriz [ix] [iy];

}

alerta (strshow);

}

//->

＜/script>

＜ Idioma do script = JavaScript>

＜!-

// ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

// window_onload

//

// getword

//reiniciar

//salvar

//carregar

//

// Showlist

// Hidelist

// Fixlist

// Valuelista

//

// ShowHelp

// hidehelp

// FixHelp

//

// RESETALL

// SaveAll

// loadall

//montar

//

// Lightbtn

// Delightbtn

// LightOpt

// DelightOpt

//

// makeopt

// RemoverOpt

// -----------------------------------------------------------

var m_ipartcnt;

var m_astrSenPart, m_astrwords;

var m_strprompt;

var m_ilistfixed, m_ihelpfixed;

// ----------------------------------------------

// Descrição da variável constante

// M_IPARTCNT: Número de categorias de vocabulário. Inteiro

// M_ASTRSENPART: o nome da classificação do vocabulário. Array do personagem

// m_astrwords: grave vários vocabulários. Array de caracteres bidimensional

// M_STRPROMPT: Mensagem imediata após a operação do arquivo ser concluída. Tipo de string

// m_ilistfixed: o número que representa a lista de palavras fixa. Inteiro

// -1 significa que nenhuma lista de palavras está corrigida

// m_ihelpfixed: o número que representa o estado fixo da lista de ajuda. Inteiro

// -1 significa que a lista de ajuda não está consertada

// ----------------------------------------------

window.onload = window_onload;

// -----------------------------------------------------------

// Inicialize a página

função window_onload ()

{

var iCount, ielecnt;

var Colbutton;

var strhelp;

// ----------------------------------------------

// Descrição da variável constante

// ICOUNT: contador. Inteiro

// ielecnt: o número de elementos na coleção. Inteiro

// Colbutton: Coleção de elementos de botão. Array do tipo objeto

// STRHELP: Ajuda o conteúdo do arquivo. Tipo de string

// ----------------------------------------------

m_ipartcnt = ＜%= m_ipartcnt%>;

m_strprompt = ＜%= m_strprompt%>;

m_ilistfixed = -1;

m_ihelpfixed = -1;

m_astrSenPart = new Array ();

m_astrwords = new Array ();

// alert (m_ipartcnt: m_ipartcnt /nm_strprompt: m_strprompt);

// Obtenha o nome da classificação do vocabulário e os vários vocabulários que foram carregados

＜%para m_icount = 0 a (m_ipartcnt - 1)%>

// Obtenha todos os tipos de vocabulário carregado

＜%Se isEmpty (m_astrwords (m_icount)) = true então%>

m_astrwords [＜%= m_icount%>] = new Array ();

＜%mais%>

m_astrwords [＜%= m_icount%>] = ＜%= junção (m_astrwords (m_icount),)%>. split (,);

＜%final se%>

// Obtenha o nome da classificação do vocabulário

m_astrSenPart [＜%= m_icount%>] = ＜%= m_astrSenPart (m_icount)%>;

＜%Próximo%>

// show2DARRAY (m_astrwords);

// ShowArray (m_astrsenPart);

// Escreva todos os tipos de vocabulário carregado na página

para (ICOUNT = 0; ICOUNT ＜ M_ipartcnt; ICOUNT)

valuelist (m_astrwords [ICOUNT], ICOUNT);

// Carregar o arquivo de ajuda

// strhelp = tblHelp.outerhtml;

// strhelp = divhelp1.innerhtml;

//tblHelp.outerhtml =;

//divhelp.innerhtml = strhelp;

//tblHelp.style.display =;

//divhelp.style.display = nenhum;

//divhelp.style.left = divhelp1.style.left;

// alert (esquerda: divhelp.style.left /nleft: divhelp1.style.left);

// alert (pixelleft: divhelp.style.pixelleft /npixelleft: divhelp1.style.pixelleft);

// alerta (posleft: divhelp.style.posleft /nposleft: divhelp1.style.posleft);

// alert (offsetLeft: divhelp.offsetleft /noffsetleft: divhelp1.offsetleft);

// alerta (clientleft: divhelp.clientleft /nclientLeft: divhelp1.clientleft);

// Especifique a função de manuseio de eventos do elemento de página

atribuifunc (txtword, getword, onkeypress);

atribuifunc (btngetword, getword);

atributfunc (btnreset, redefinir);

atributfunc (btnsave, salvar);

atribuifunc (btnload, carregamento);

atributfunc (lblwordlist, showlist, onMouseOver);

atributfunc (lblwordlist, hidelist, onmouseout);

atributfunc (lblwordlist, fixlist);

atributfunc (lblHelp, showhelp, onMouseOver);

atributfunc (lblHelp, hideHelp, onMouseOut);

atributfunc (lblHelp, fixHelp);

atribuifunc (btnresetall, redefinitel);

cessionFunc (BtnsAveall, SaveAll);

atribuifunc (btnloadall, loadall);

atribuifunc (btnasb, montagem);

colbutton = document.all.tags (botão);

ielecnt = colbutton.length;

// ShowArray (Colbutton);

// alert (ielecnt: ielecnt);

para (ICOUNT = 0; ICOUNT ＜ IELECNT; ICOUNT)

{

cessionFunc (Colbutton [ICOUNT], Lightbtn, OnMouseOver);

cessionFunc (Colbutton [ICOUNT], Delightbtn, OnMouseOut);

}

// Defina o status inicial da página

if (m_strprompt! =)

alerta (m_strprompt);

txtword [0] .focus ();

}

// -----------------------------------------------------------

// Obtenha a palavra inserida pelo usuário

função getword ()

{

// somente quando pressione Enter ou na caixa de entrada da palavra

// continua fazendo isso ao pressionar o botão Salvar

if (window.event.type! = keypress && window.event.type! = clique)

retornar;

outro

if (window.event.type == keypress && window.event.keycode! = 13) return;

var elesrc;

var iindex, inxtwrdidx;

var strword;

// ----------------------------------------------

// Descrição da variável constante

// elesrc: o elemento onde o evento ocorreu

// iindex: número representando a classificação do vocabulário. Inteiro

// inxtwrdidx: o índice de novas palavras na matriz de palavras. Inteiro

// strword: a palavra inserida pelo usuário. Tipo de string

// ----------------------------------------------

elesrc = window.event.srcelement;

iIndex = getEleIndex (ELESRC); // obtenha índice

strword = TRIM (txtword [iindex] .Value); // Obtenha a palavra inserida pelo usuário

// detecta se a palavra inserida é legal

// Se for uma palavra ilegal, saia

if (strword ==)

{

// se a palavra inserida estiver vazia ou string espacial

alerta (as palavras não podem estar vazias ou string espacial);

txtword [iindex] .select ();

retornar;

}

if (strword.indexof (,)! = -1 || strword.indexof ()! = -1)

{

// Se a palavra inserida contiver vírgulas ou espaços

alerta (palavras não podem conter vírgulas ou espaços);

txtword [iindex] .select ();

retornar;

}

// salvar palavras em matriz de vocabulário

inxtWrdidx = m_astrwords [iindex] .Length;

m_astrwords [iindex] [inxtWrdidx] = strword;

// showArray (m_astrwords [iindex]);

// Escreva palavras na página

valuelist (m_astrwords [iindex], iindex);

txtword [iindex] .Value =;

txtword [iindex] .focus ();

}

// -----------------------------------------------------------

// Exclua todas as palavras na categoria atual da memória

função reset ()

{

var elesrc;

var iindex, ICOUNT;

var strprompt;

// ----------------------------------------------

// Descrição da variável constante

// elesrc: o elemento onde o evento ocorreu

// iindex: número representando a classificação do vocabulário. Inteiro

// ICOUNT: contador. Inteiro

// strprompt: prompt de operação. Tipo de string

// ----------------------------------------------

elesrc = window.event.srcelement;

iIndex = getEleIndex (ELESRC);

strprompt = tem certeza de que deseja limpar todas as palavras na parte [m_astrsenPart [iindex]] da memória? ;

if (window.confirm (strprompt) == false) retornar;

m_astrwords [iindex] = new Array ();

valuelist (m_astrwords [iindex], iindex);

// showArray (m_astrwords [iindex]);

strprompt = palavra limpa;

alerta (strprompt);

txtword [iindex] .select ();

}

// -----------------------------------------------------------

// salvar o vocabulário atual da categoria selecionada no arquivo

função salvar ()

{

var elesrc;

var iindex, ICOUNT;

// ----------------------------------------------

// Descrição da variável constante

// elesrc: o elemento onde o evento ocorreu

// iindex: número representando a classificação do vocabulário. Inteiro

// ICOUNT: contador. Inteiro

// ----------------------------------------------

elesrc = window.event.srcelement;

iIndex = getEleIndex (ELESRC);

if (m_astrwords [iindex] .Length == 0)

{

// Se o número atual de palavras na categoria selecionada for zero

var strprompt;

strprompt = [m_astrSenPart [iindex]] agora não tem palavra opcional, você tem certeza de que deseja salvá -la? ;

strprompt = /n (isso gerará um novo arquivo vazio);

if (window.confirm (strprompt) == false) retornar;

}

// Salve todas as palavras na memória atual

para (ICOUNT = 0; ICOUNT ＜ M_ipartcnt; ICOUNT)

Eval (frmwords.txtwords icount) .Value = m_astrwords [ICOUNT] .Join (,);

frmwords.txtsenpart.value = iindex;

frmwords.txtopway.value = salvar;

frmwords.subMit ();

}

// -----------------------------------------------------------

// leia registros de palavras da categoria selecionada do arquivo

carga de função ()

{

var elesrc;

var iindex, ICOUNT;

// ----------------------------------------------

// Descrição da variável constante

// elesrc: o elemento onde o evento ocorreu

// iindex: número representando a classificação do vocabulário. Inteiro

// ICOUNT: contador. Inteiro

// ----------------------------------------------

elesrc = window.event.srcelement;

iIndex = getEleIndex (ELESRC);

// Salve todas as palavras na memória atual

para (ICOUNT = 0; ICOUNT ＜ M_ipartcnt; ICOUNT)

Eval (frmwords.txtwords icount) .Value = m_astrwords [iCount] .Join (,)

frmwords.txtsenpart.value = iindex;

frmwords.txtopway.value = load;

frmwords.subMit ();

}

// -----------------------------------------------------------

// Mostrar lista de vocabulário

Função Showlist (iindex)

{

// se o parâmetro iindex não for dado

// Obtenha iindex

if (iindex == indefinido)

{

// Se a lista de palavras já estiver corrigida, saia da função

if (m_ilistfixed! = -1) retornar;

var elesrc;

var iindex;

// ----------------------------------------------

// Descrição da variável constante

// elesrc: o elemento onde o evento ocorreu

// iindex: número representando a classificação do vocabulário. Inteiro

// ----------------------------------------------

elesrc = window.event.srcelement;

iIndex = getEleIndex (ELESRC);

}

// alerta (iindex: iindex);

// Mostrar lista de vocabulário

//lblwordListList[index ].innerText = [lblwordList [iindex] .innerText];

//lblwordListList~Index ].innerText = lblwordList [iindex] .innerText ＞;

lblwordList [iindex] .className = lblMover;

DivwordList [iindex] .className = listshown;

}

// -----------------------------------------------------------

// Ocultar lista de vocabulário

função hidelist (iindex)

{

// se o parâmetro iindex não for dado

// Obtenha iindex

if (iindex == indefinido)

{

// Se a lista de palavras já estiver corrigida, saia da função

if (m_ilistfixed! = -1) retornar;

var elesrc;

var iindex;

// ----------------------------------------------

// Descrição da variável constante

// elesrc: o elemento onde o evento ocorreu

// iindex: número representando a classificação do vocabulário. Inteiro

// ----------------------------------------------

elesrc = window.event.srcelement;

iIndex = getEleIndex (ELESRC);

}

// alerta (iindex: iindex);

// Ocultar lista de vocabulário

//lblwordListList[index ].innerText = lblwordList [iindex] .innerText.slice (0, -1);

lblwordList [iindex] .className = lblmout;

DivwordList [iindex] .className = listhidden;

}

// -----------------------------------------------------------

// Lista de vocabulário fixo

função fixlist ()

{

var elesrc;

var iindex;

// ----------------------------------------------

// Descrição da variável constante

// elesrc: o elemento onde o evento ocorreu

// iindex: número representando a classificação do vocabulário. Inteiro

// ----------------------------------------------

elesrc = window.event.srcelement;

iIndex = getEleIndex (ELESRC);

Switch (m_ilistfixed)

{

Caso -1:

// Se ainda não houver lista de palavras

// Corrija a lista atual

m_ilistfixed = iindex;

lblwordList [iindex] .className = lblClicked;

DivwordList [iindex] .className = listfixed;

quebrar;

caso iindex:

// se a lista de palavras fixa for a lista atual

// Resolva a lista atual

m_ilistfixed = -1;

lblwordList [iindex] .className = lblMover;

DivwordList [iindex] .className = listshown;

quebrar;

padrão:

// se a lista de palavras fixa não for a lista atual

// A lista de correções fixas

hidelist (m_ilistfixed);

m_ilistfixed = -1;

lblwordList [iindex] .className = lblMover;

Showlist (iindex);

quebrar;

}

// alert (m_ilistfixed: m_ilistfixed /niIndex: iindex);

}

// -----------------------------------------------------------

// Escreva palavras carregadas em um certo tipo de vocabulário

função valuelista (AWORDS, ISENPART)

{

var iCount, iwrdcnt;

var strlistppt;

// ----------------------------------------------

// Descrição da variável constante

// ICOUNT: contador. Inteiro

// iwrdcnt: o número de palavras de um certo tipo de vocabulário. Inteiro

// strlistppt: prompt na lista de palavras. Tipo de string

// ----------------------------------------------

// Preparação de dados

iwrdcnt = awords.length;

lblwordCount [isenPart] .innerText = iwrdcnt;

strlistppt = ＜ div ＞＜ span style = 'cor: vermelho; estilo de fonte: itálico; tamanho de fonte: 10.5pt; '>;

strlistppt = clique duas vezes na palavra para excluí-la </span> </div>;

// Escreva palavras para listar

if (iwrdcnt! = 0)

{

DivwordList [isenPart] .innerhtml = strlistppt;

para (ICOUNT = 0; ICOUNT ＜ IWRDCNT; ICOUNT)

DivwordList [isenPart] .innerhtml = makeopt (AWORDS [ICOUNT], ICOUNT);

}

outro

DivwordList [isenPart] .innerhtml = strlistppt;

}

// -----------------------------------------------------------

// Mostrar a lista de ajuda

função showhelp ()

{

// Se a lista de ajuda tiver sido corrigida, saia da função

if (m_ihelpfixed == 0) retornar;

// mostra ajuda

lblHelp.className = lblMover;

divhelp.className = helpShown;

}

// -----------------------------------------------------------

// Ocultar lista de ajuda

função hideHelp ()

{

// Se a lista de ajuda tiver sido corrigida, saia da função

if (m_ihelpfixed == 0) retornar;

// Ocultar ajuda

lblHelp.className = lblmout;

divhelp.className = HelpHidden;

}

// -----------------------------------------------------------

// Lista de ajuda corrigida

função fixHelp ()

{

if (m_ihelpfixed == -1)

{

// se a lista de ajuda não tiver sido consertada

// conserte

m_ihelpfixed = 0;

lblHelp.className = lblClicked;

divhelp.className = helpFixed;

}

outro

{

// se a lista de ajuda tiver sido corrigida

// Resolva -o

m_ihelpfixed = -1;

lblHelp.className = lblMover;

divhelp.className = helpShown;

}

}

// -----------------------------------------------------------

// Redefina a página para o estado inicial

Função Resetall ()

{

var iCount;

// ----------------------------------------------

// Descrição da variável constante

// ICOUNT: contador. Inteiro

// ----------------------------------------------

para (ICOUNT = 0; ICOUNT ＜ M_ipartcnt; ICOUNT)

{

txtword [ICOUNT] .Value =;

m_astrwords [iCount] = new Array (); // esvazia a palavra matriz

valuelist (m_astrwords [ICOUNT], ICOUNT);

}

txtSentence.value =;

txtword [0] .focus ();

}

// -----------------------------------------------------------

// salve todas as categorias de palavras no arquivo

função saveall ()

{

var iCount, iEmptycnt;

var strprompt;

// ----------------------------------------------

// Descrição da variável constante

// ICOUNT: contador. Inteiro

// iEmptycnt: o número de categorias com 0 palavras. Inteiro

// strprompt: prompt de operação. Tipo de string

// ----------------------------------------------

iEmptyCnt = 0;

para (ICOUNT = 0; ICOUNT ＜ M_ipartcnt; ICOUNT)

{

// Salve todas as palavras na memória atual

Eval (frmwords.txtwords icount) .Value = m_astrwords [ICOUNT] .Join (,);

if (m_astrwords [iCount] .Length == 0)

IEMPTYCNT;

}

// alert (iEmptycnt: iEmptycnt);

if (iEmptycnt ＞ 0)

{

Switch (iEmptycnt)

{

caso m_ipartcnt:

strprompt = o número de palavras de vocabulário em todas as categorias é 0, e a operação produzirá arquivos vazios M_IPARTCNT;

strprompt = /n tem certeza de que deseja fazer isso? ;

quebrar;

padrão:

strprompt = onde;

para (ICOUNT = 0; ICOUNT ＜ M_ipartcnt; ICOUNT)

if (m_astrwords [iCount] .Length == 0)

strprompt = [m_astrsenPart [icount]];

strprompt = strprompt.slice (0, -1);

strprompt = o número de algumas palavras é 0;

StrPrompt = /N operação gerará arquivos vazios iEmptyct;

strprompt =, tem certeza de que deseja fazer isso? ;

}

if (window.confirm (strprompt) == false) retornar;

}

frmwords.txtopway.value = SaveAll;

frmwords.subMit ();

}

// -----------------------------------------------------------

// carrega todas as categorias de palavras do arquivo

função loadall ()

{

var iCount;

// ----------------------------------------------

// Descrição da variável constante

// ICOUNT: contador. Inteiro

// ----------------------------------------------

// Salve todas as palavras na memória atual

para (ICOUNT = 0; ICOUNT ＜ M_ipartcnt; ICOUNT)

Eval (frmwords.txtwords icount) .Value = m_astrwords [iCount] .Join (,)

frmwords.txtopway.value = loadall;

frmwords.subMit ();

}

// -----------------------------------------------------------

// por favor vocabulário combine e receba uma frase

função montagem ()

{

var iCount, iwrdcnt, irndindex;

var strsentence;

// ----------------------------------------------

// Descrição da variável constante

// ICOUNT: contador. Inteiro

// iwrdcnt: o número de palavras de um certo tipo de vocabulário. Inteiro

// irndindex: índice de palavras geradas aleatoriamente. Inteiro

// Strsentence: uma frase composta por palavras aleatórias em cada categoria de vocabulário. Tipo de string

// ----------------------------------------------

StrSENTENCE =;

para (ICOUNT = 0; ICOUNT ＜ M_ipartcnt; ICOUNT)

{

// Se o número atual de vocabulário na categoria for 0

// Dê um rápido e aborta a colocação

iWrdCnt = m_astrWords[iCount].length;

if (iWrdCnt == 0)

{

var strPrompt;

//------------------------------------------

//常变量说明

//strPrompt ：操作提示。字符串型

//------------------------------------------

strPrompt = [ m_astrSenPart[iCount] ]部分一个可选单词也没有;

strPrompt = /n请至少输入一个单词;

alert(strPrompt);

txtWord[iCount].select();

retornar;

}

//随机抽取当前类别词汇中的一个单词

//加入到句子中

iRndIndex = Math.floor(Math.random()*iWrdCnt);

strSentence = m_astrWords[iCount][iRndIndex];

//alert(iWrdCnt: iWrdCnt /niRndIndex: iRndIndex);

}

strSentence = . ;

txtSentence.value = strSentence;

}

//使鼠标移到之处的按钮

//产生点亮的效果

function lightBtn()

{

var eleSrc;

//------------------------------------------

//常变量说明

//eleSrc ：发生事件的元素

//------------------------------------------

eleSrc = window.event.srcElement;

while (eleSrc.tagName.toUpperCase() != BUTTON)

eleSrc = eleSrc.parentElement;

eleSrc.className = btnLighted;

}

//使鼠标离开的按钮

//还原为初始状态

function delightBtn()

{

var eleSrc;

//------------------------------------------

//常变量说明

//eleSrc ：发生事件的元素

//------------------------------------------

eleSrc = window.event.srcElement;

while (eleSrc.tagName.toUpperCase() != BUTTON)

eleSrc = eleSrc.parentElement;

eleSrc.className = btnDelighted;

}

//在列表中，使鼠标移到之处的单词

//产生点亮的效果

function lightOpt(ele)

{

var eleSrc;

//------------------------------------------

//常变量说明

//eleSrc ：发生事件的元素

//------------------------------------------

eleSrc = ele;

eleSrc.className = optLighted;

}

//在列表中，使鼠标离开的单词

//还原为初始状态

function delightOpt(ele)

{

var eleSrc;

//------------------------------------------

//常变量说明

//eleSrc ：发生事件的元素

//------------------------------------------

eleSrc = ele;

eleSrc.className = optDelighted;

}

//得到定义过的将加入列表的单词

function makeOpt(strWord, iWrdIdx)

{

var strOptHead, strOptFoot;

var strOptWord;

//------------------------------------------

//常变量说明

//strOptHead ：重定义单词头。字符串型

//strOptFoot ：重定义单词尾。字符串型

//strOptWord ：重定义单词。字符串型

//------------------------------------------

strOptHead = ＜div class='optDelighted' onmouseover='lightOpt(this);' onmouseout='delightOpt(this);' ondblclick='removeOpt(this);' wrdIdx=' iWrdIdx '＞;

strOptFoot = ＜/div＞;

strOptWord = strOptHead strWord strOptFoot;

//alert(strOptWord);

return strOptWord;

}

//删除列表中的单词

function removeOpt(ele)

{

var eleSrc;

var iIndex, iWrdIdx;

var astrWords, astrHead, astrFoot;

//------------------------------------------

//常变量说明

//eleSrc ：发生事件的元素

//iIndex ：表示词汇分类的数字。整型

//iWrdIdx ：单词在单词数组中的索引。整型

//astrWords ：某类词汇单词数组。字符串型数组

//astrHead ：某类词汇单词数组头部分。字符串型数组

//astrFoot ：某类词汇单词数组尾部分。字符串型数组

//------------------------------------------

eleSrc = ele;

iIndex = getEleIndex(eleSrc.parentElement);

iWrdIdx = parseInt(eleSrc.wrdIdx);

//将单词从词汇数组中删去

//showArray(m_astrWords[iIndex]);

astrWords = m_astrWords[iIndex].concat();

astrHead = astrWords.slice(0, iWrdIdx);

astrFoot = astrWords.slice(iWrdIdx 1);

m_astrWords[iIndex] = astrHead.concat(astrFoot);

//showArray(astrHead);

//showArray(astrFoot);

//showArray(m_astrWords[iIndex]);

//将剩余的单词重新写入到页面中

valueList(m_astrWords[iIndex], iIndex);

txtWord[iIndex].select();

}

//--＞

＜/script＞

＜/head＞

＜body＞

＜!--标题--＞

＜div align=CENTER＞

＜span style=font-size: 20pt; font-weight: BOLD＞词语搭配游戏＜/span＞

＜span class=fontEng2＞v1.0＜/span＞

＜/div＞

＜hr style=visibility: HIDDEN＞

＜!--主表格1--＞

＜table border=0 align=CENTER width=80%＞

＜colgroup＞＜/colgroup＞

＜colgroup＞＜/colgroup＞

＜colgroup＞＜/colgroup＞

＜colgroup＞＜/colgroup＞

＜colgroup＞＜/colgroup＞

＜colgroup＞＜/colgroup＞

＜colgroup align=CENTER＞＜/colgroup＞

＜colgroup＞＜/colgroup＞

＜%For m_iCount = 0 To (m_iPartCnt - 1)%＞

＜tr＞

＜td＞＜%= m_astrSenPart(m_iCount)%＞＜/td＞

＜td width=20%＞＜input type=text id=txtWord style=width: 100%＞＜/td＞

＜td＞＜button id=btnGetWord style=width: 75px title=将单词保存到内存中＞保存＜/button＞＜/td＞

＜td＞＜button id=btnReset style=width: 75px title=从内存中删去当前类别所有的单词＞重置＜/button＞＜/td＞

＜td＞＜button id=btnSave style=width: 75px title=将单词保存到文件中＞存入＜/button＞＜/td＞

＜td＞＜button id=btnLoad style=width: 75px title=从文件中载入单词＞载入＜/button＞＜/td＞

＜td width=15%＞＜label id=lblWordList title=单击固定我＞单词列表＜/label＞＜/td＞

＜td＞

＜div id=divWordList class=listHidden＞＜/div＞

个数：＜label id=lblWordCount class=fontEng1＞＜%= 0%＞＜/label＞

＜/td＞

＜/tr ＞

＜%Next%＞

＜/table＞

＜hr style=visibility: HIDDEN＞

＜hr style=color: BLUE＞

＜!--主表格2--＞

＜table border=0 align=CENTER width=80%＞

＜colgroup width=16%＞＜/colgroup＞

＜colgroup width=16%＞＜/colgroup＞

＜colgroup width=16%＞＜/colgroup＞

＜colgroup＞＜/colgroup＞

＜tr＞

＜td＞＜button id=btnResetAll accesskey=r title=从内存中删去所有类别的单词class=btnDelighted＞全部重置＜u＞R＜/u＞＜/button＞＜/td＞

＜td＞＜button id=btnSaveAll accesskey=s title=将所有类别的单词保存到文件中class=btnDelighted＞全部存入＜u＞S＜/u＞＜/button＞＜/td＞

＜td＞＜button id=btnLoadAll accesskey=l title=从文件中载入所有类别的单词class=btnDelighted＞全部载入＜u＞L＜/u＞＜/button＞＜/td＞

＜td＞

＜span style=font-size: 9pt; color: RED;＞请单击＜/span＞ ＜label id=lblHelp title=单击固定我＞游戏说明＜/label＞

＜!--帮助说明表格--＞

＜div id=divHelp class=helpHidden＞

＜table id=tblHelp border=0 align=CENTER width=300px style=font-size: 9pt;＞

＜colgroup width=75px＞＜/colgroup＞

＜colgroup＞＜/colgroup＞

＜tr＞＜td colspan=2＞

＜a href=#1 style=color: BLUE;＞游戏步骤＜/a＞

＜a href=#2 style=color: BLUE;＞操作说明＜/a＞

＜a href=#3 style=color: BLUE;＞游戏起源＜/a＞

＜a href=#4 style=color: BLUE;＞制作原因＜/a＞

＜a href=#5 style=color: BLUE;＞游戏功效＜/a＞

＜a name=0 style=display: NONE;＞TOP＜/a＞

＜/td＞＜/tr＞

＜!--游戏步骤--＞

＜tr＞＜td colspan=2＞＜/td＞＜/tr＞

＜tr＞＜td colspan=2＞

[＜a name=1 style=color: BLUE;＞游戏步骤＜/a＞]

＜a href=#0 class=link＞TOP＜/a＞

＜/td＞＜/tr＞

＜tr＞＜td colspan=2＞

＜span class=fontEng1＞＜1＞＜/span＞在每个部分的＜span class=fontEmp＞输入框＜/span＞中输入单词， 按＜span class=fontEmp＞回车＜/span＞或＜span class=fontEmp＞保存＜/span＞按钮存入内存中；

或按＜span class=fontEmp＞载入＜/span＞按钮调出以前保存的某类别单词纪录；

或按＜span class=fontEmp＞全部载入＜/span＞按钮调出以前保存的所有类别单词纪录＜br＞

＜span class=fontEng1＞＜2＞＜/span＞按＜span class=fontEmp＞开始搭配＜/span＞按钮，系统将从各类单词中随机抽取一个，组成一个句子

＜/td＞＜/tr＞

＜!--操作说明--＞

＜tr＞＜td colspan=2＞＜/td＞＜/tr＞

＜tr＞＜td colspan=2＞

[＜a name=2 style=color: BLUE;＞操作说明＜/a＞]

＜a href=#0 class=link＞TOP＜/a＞

＜/td＞＜/tr＞

＜tr＞

＜td＞保存＜/td＞

＜td＞得到用户输入的单词＜/td＞

＜/tr ＞

＜tr＞

＜td＞重置＜/td＞

＜td＞将当前类别所有的单词从内存中删去＜/td＞

＜/tr ＞

＜tr＞

＜td＞存入＜/td＞

＜td＞将所选类别的当前词汇保存进文件中＜/td＞

＜/tr ＞

＜tr＞

＜td＞载入＜/td＞

＜td＞从文件中读取所选类别的单词纪录＜/td＞

＜/tr ＞

＜tr＞

＜td＞全部重置＜/td＞

＜td＞重置页面至初始状态＜/td＞

＜/tr ＞

＜tr＞

＜td＞全部保存＜/td＞

＜td＞把所有类别的单词都存入文件＜/td＞

＜/tr ＞

＜tr＞

＜td＞全部载入＜/td＞

＜td＞从文件中载入所有类别的单词＜/td＞

＜/tr ＞

＜tr＞

＜td＞开始搭配＜/td＞

＜td＞进行词汇搭配，得到一个句子＜/td＞

＜/tr ＞

＜tr＞＜td＞＜/td＞＜/tr＞

＜tr＞＜td colspan=2＞

＜span class=fontEng1＞＜1＞＜/span＞

＜span class=fontEmp＞将鼠标移至单词列表处＜/span＞，会弹出该类词汇的单词列表；

＜span class=fontEmp＞将鼠标移开＜/span＞，列表会自动隐藏；

＜span class=fontEmp＞点击单词列表＜/span＞，会固定单词列表；

＜span class=fontEmp＞再次点击＜/span＞，会取消固定＜br＞

＜span class=fontEng1＞＜2＞＜/span＞

在＜span class=fontEmp＞固定住一个单词列表＜/span＞后，

＜span class=fontEmp＞双击＜/span＞该列表中的某个单词，可以将该单词从内存中删去＜br＞

＜span class=fontEng1＞＜3＞＜/span＞

输完一个单词后，＜span class=fontEmp＞直接按回车＜/span＞就可以保存了，这样比按保存保存单词更方便

＜/td＞＜/tr＞

＜!--游戏起源--＞

＜tr＞＜td colspan=2＞＜/td＞＜/tr＞

＜tr＞＜td colspan=2＞

[＜a name=3 style=color: BLUE;＞游戏起源＜/a＞]

＜a href=#0 class=link＞TOP＜/a＞

＜/td＞＜/tr＞

＜tr＞＜td colspan=2＞

这个游戏想法来自于小时候玩的纸团游戏。那时和姐姐在家里闲得无聊，就玩这个，哈哈。

玩法很简单，做一些纸片，分成四堆，分别写上＜span class=fontEmp＞亲朋好友的名字＜/span＞、＜span class=fontEmp＞形容程度的词语＜/span＞、＜span class=fontEmp＞关于地点的词语＜/span＞和＜span class=fontEmp＞所做的事情＜/span＞。

然后，将纸片捏成纸团，＜span class=fontEng1＞OK, Let's Start!＜/span＞ 现在从每堆中抽出一个纸团，就有四个词语，将它们组成一句话，因为是随便抽的，有时能组成很搞笑的句子。

如：陈楠兴奋地在大街上跳夏威夷草裙舞；万民悠闲地在公园里洗澡。^_

＜/td＞＜/tr＞

＜!--制作原因--＞

＜tr＞＜td colspan=2＞＜/td＞＜/tr＞

＜tr＞＜td colspan=2＞

[＜a name=4 style=color: BLUE;＞制作原因＜/a＞]

＜a href=#0 class=link＞TOP＜/a＞

＜/td＞＜/tr＞

＜tr＞＜td colspan=2＞

主要是无聊，想做个游戏娱乐一下自己，当然也希望大家能从中得到笑声。

Secondly, I also want to exercise my skills. I used to do one with <span class=fontEng1>VB</span>, but it was not very good. This time I used <span class=fontEng1>ASP</span>. I don’t know if there has been any progress. Haha

这个版本我大概地测试了一下，没发现大的＜span class=fontEng1＞bug＜/span＞。如果您在游戏中发现了问题或有什么建议，请一定告诉我，在此先谢谢了！

我的信箱是＜a href=mailto: [email protected] class=link＞[email protected]＜/a＞。不好你就说吗！不可能你说好我又说不好，你不说好我又说好的，^_

＜/td＞＜/tr＞

＜!--游戏功效--＞

＜tr＞＜td colspan=2＞＜/td＞＜/tr＞

＜tr＞＜td colspan=2＞

[＜a name=5 style=color: BLUE;＞游戏功效＜/a＞]

＜a href=#0 class=link＞TOP＜/a＞

＜/td＞＜/tr＞

＜tr＞＜td colspan=2＞

因为是搞笑游戏，所以能使你心情愉快、青春焕发，间接增加找对象的成功率；

因为不用做纸团了，减少了浪费和污染，从而美化了世界环境；

I believe there are many benefits, please help me find it. Ha ha.

＜/td＞＜/tr＞

＜/table＞

＜/div＞

＜/td＞

＜/tr ＞

＜tr＞

＜td＞＜button id=btnAsb accesskey=a title=从每个类别词汇中随机抽取一个单词，组成一个句子class=btnDelighted＞开始搭配＜u＞A＜/u＞＜/button＞＜/td＞

＜td colspan=3＞＜input type=text id=txtSentence style=width: 100%＞＜/td＞

＜/tr ＞

＜/table＞

＜hr style=color: BLUE＞

＜!--提交表单--＞

＜form id=frmWords method=POST action= style=display: NONE;＞

＜%For m_iCount = 0 To (m_iPartCnt - 1)%＞

＜input type=text name=txtWords＜%= m_iCount%＞＞

＜%Next%＞

＜input type=text name=txtSenPart＞

＜input type=text name=txtOpWay＞

＜/forma ＞

＜!--版权--＞

＜div align=CENTER＞

＜div＞

© ＜span class=fontEng2＞2001 China Sentin Sci. & Tech. Co., Ltd.＜/span＞

＜span class=fontEng2＞All Rights Reserved.＜/span＞

＜/div＞

＜div＞

＜span class=fontEng2＞Authored by＜/span＞ ＜a href=mailto: [email protected] class=link＞Recon＜/a＞＜/span＞

＜a href=http://recon.top263.net/ class=link＞http://recon.top263.net/＜/a＞

＜/div＞

＜/div＞

＜/body＞

＜/html＞

＜%

'以下是服务器端脚本

'用到的函数和过程

'************************

'函数名：SaveFile

'功能：将某类词汇保存到文件中

'输入：1、iSenPart ：表示词汇分类的数字。整型

' 可能的值有：

' 0：主语

' 1：程度状语

' 2：地点状语

' 3：谓语

'输出：对文件操作后的状态值。整型

' 可能的值有：

' 0：操作成功

' 1：操作失败

'************************

Function SaveFile(iSenPart)

Dim fsoMain, tsfWords

Dim iCount, iWrdCnt

Dim iOpStatus

'------------------------------------------

'常变量说明

'fsoMain ：FSO对象

'tsfWords ：TEXTSTREAM对象

'iCount ：计数器。整型

'iWrdCnt ：某类词汇单词的数目。整型

'iOpStatus ：文件操作完毕后的状态。整型

'------------------------------------------

Set fsoMain = Server.CreateObject(SCRIPTING.FILESYSTEMOBJECT)

Set tsfWords= fsoMain.CreateTextFile(m_strFilePath & m_astrFileName(iSenPart), True)

tsfWords.WriteLine([ & m_astrSenPart(iSenPart) & 部分])

'如果该类别至少有一个单词

If IsEmpty(m_astrWords(iSenPart)) = False Then

iWrdCnt = UBound(m_astrWords(iSenPart)) 1

For iCount = 0 To (iWrdCnt - 1)

tsfWords.WriteLine(m_astrWords(iSenPart)(iCount))

Próximo

End If

tsfWords.Close

iOpStatus = 0

SaveFile = iOpStatus

Função final

'************************

'函数名：LoadFile

'功能：从文件中载入某类词汇

'输入：1、iSenPart ：表示词汇分类的数字。整型

' 可能的值有：

' 0：主语

' 1：程度状语

' 2：地点状语

' 3：谓语

'输出：对文件操作后的状态值。整型

' 可能的值有：

' 0：操作成功

' 1：操作失败

'************************

Function LoadFile(iSenPart)

Dim fsoMain, tsfWords

Dim strLoaded

Dim iOpStatus

'------------------------------------------

'常变量说明

'fsoMain ：FSO对象

'tsfWords ：TEXTSTREAM对象

'strLoaded ：某类词汇所有单词构成的字符串。字符串型

'iOpStatus ：文件操作完毕后的状态。整型

'------------------------------------------

Set fsoMain = Server.CreateObject(SCRIPTING.FILESYSTEMOBJECT)

If fsoMain.FileExists(m_strFilePath & m_astrFileName(iSenPart)) = True Then

'如果存在纪录文件

strLoaded =

Set tsfWords= fsoMain.OpenTextFile(m_strFilePath & m_astrFileName(iSenPart), 1)

tsfWords.SkipLine

Do While tsfWords.AtEndOfStream = False

strLoaded = strLoaded & tsfWords.ReadLine & ,

Laço

If strLoaded ＜＞ Then

strLoaded = Left(strLoaded, Len(strLoaded) - 1)

m_astrWords(iSenPart) = Split(strLoaded, ,)

Outro

m_astrWords(iSenPart) = Empty

End If

tsfWords.Close

iOpStatus = 0

Outro

'如果不存在纪录文件

iOpStatus = 1

End If

LoadFile = iOpStatus

Função final

%＞

＜%

'以下是服务器端脚本

'用于测试的函数和过程

Sub Show(strDef)

Response.Write strDef & : & Eval(strDef) & ＜br＞

Final sub

Sub ShowMethod()

Response.Write Request Method: & Request.ServerVariables(REQUEST_METHOD) & ＜br＞

Final sub

Sub ShowForm()

Dim Icount

Dim strProp

iCount = 0

Response.Write *********Form Information******＜br＞

For Each strProp In Request.Form

iCount = iCount 1

Response.Write iCount & . & strProp & : & Request.Form(strProp) & ＜br＞

Próximo

Response.Write *********Form End**************＜br＞

Final sub

%＞