设为首页收藏本站
切换到宽版

 找回密码
 注册
搜索
批处理之家»论坛 › 批处理专区: BAT CMD DOS › 开源原创工具 › powerimg一款图显脚本解释器
[新手上路]批处理新手入门导读[视频教程]批处理基础视频教程[视频教程]VBS基础视频教程[批处理精品]批处理版照片整理器
[批处理精品]纯批处理备份&还原驱动[批处理精品]CMD命令50条不能说的秘密[在线下载]第三方命令行工具[在线帮助]VBScript / JScript 在线参考
返回列表 发新帖
查看: 21253|回复: 9

powerimg一款图显脚本解释器

[复制链接]
happy886rr
发表于 2016-11-27 20:02:36 | 显示全部楼层 |阅读模式
本帖最后由 happy886rr 于 2016-11-27 20:05 编辑
POWERIMG.EXE
_____________________________________________________________________________
powerimg是一款强大的控制台图显脚本解释器，支持jpg、png、bmp等多种图片格式
该脚本解析器具有类似批处理的标签、跳转、循环、CALL等语法。完全是逐行解释
逐行运行，与批处理的解释机制非常相似，但语法风格略有不同，所有关键字一律
只有3个字符。
_____________________________________________________________________________
下载图片存为a.zip解压即是。

-----------------------------------------------------------------------------
主要关键字：(不区分大小写)
"add", "rot", "zom", "rev", "alp", "arg", "img", "slp", "lib", "jmp", "pos",
"exi", "pau", "cls", "tit", "mod", "cot", "mvw", "cal", "eof", "ech", "cur"

ROT [旋转中心x坐标] [旋转中心y坐标] [初始相位角度值] [角度增量]
ZOM [缩放中心x坐标] [缩放中心y坐标] [横向缩放率] [纵向缩放率] [横向缩放率增量] [纵向缩放率增量]
REV [模式值(-2到2)]
ALP [模式值( 0或1)] [R] [G] [B]
ADD [x坐标增量] [y坐标增量] [宽度大小增量] [高度大小增量] [x剪切坐标增量] [y剪切坐标增量] [显示的长度增量] [显示的高度增量]
ARG [x坐标] [y坐标] [宽度大小] [高度大小] [x剪切坐标] [y剪切坐标] [显示的长度] [显示的高度]
IMG [图片名]
JMP [#标签名]
CAL [#标签名]
COT [1|2|4|8] [1|2|4|8] [1|2|4|8] [16|32|64|128]
POS [x] [y]
MVW [x] [y]
CUR [光标尺寸]
SLP [延时毫秒]

其余ECH、PAU、TIT、CLS、EXI、MOD、CAL、均同批处理的echo, pause, title, cls,
exit, mode, con, call.
-----------------------------------------------------------------------------
注释符格式：

行注释  //        行内容
段注释  /*     
                段内容
        */
-----------------------------------------------------------------------------
自然宏命令：

||start the img script   //每个powerimg脚本必须有的，脚本的开始标记
||using desktop window   //使用桌面而非控制台来显示
||hide the cursor        //隐藏光标
||end the img script     //脚本的结束
||eof
-----------------------------------------------------------------------------
库调用格式：
LIB ||[库文件路径]  [参数1] |[参数2]
-----------------------------------------------------------------------------
百叶窗示例：
//////////////////////////////////////////////////////
Shutter effects

//////////////////////////////////////////////////////

||start img script
||hide the cursor

[
        [
                ADD 0 -50
                ARG 0 500, 0 0, 0 0, 500 50
                IMG test.jpg
                ADD 0 -50
                ARG 0 550, 500 50
                IMG
                SLP 3
        ]10
        ADD 0 0, 0 0, 0 50
]18,-1

||eof
-----------------------------------------------------------------------------
旋转图片示例：
//////////////////////////////////////////////////////
Rote effects

//////////////////////////////////////////////////////

||start img script
||hide the cursor

[
        ROT 0 0,  0 10
        IMG test.jpg
        SLP 3
]18,-1

||eof
-----------------------------------------------------------------------------
标签的使用：
//在批处理中:代表标签的开始，但在powerimg中#才是一个标签的开始，goto用JMP代替

//////////////////////////////////////////////////////
Label effects

//////////////////////////////////////////////////////

||start img script
||hide the cursor
#start
        ECH 你好！
        EOF
JMP #start
CAL #start

||eof
-----------------------------------------------------------------------------
循环的使用：
//在powerimg中中括号就是循环，括号后的数字就是循环的次数

//////////////////////////////////////////////////////
For effects

//////////////////////////////////////////////////////

||start img script
||hide the cursor

[
        ECH 循环内容

//8代表循环8次
]8

||eof
-----------------------------------------------------------------------------
英译：
THE CONSOLE DISPLAYS A PICTURE SCRIPT, VERSION 1.0
COPYRIGHT@2016~2018 BY HAPPY
POWERIMG.EXE

USAGE: powerimg [scriptfile]
-----------------------------------------------------------------------------
11/27/2016


核心源码：
  1. /*
  2.         THE CONSOLE DISPLAYS A PICTURE SCRIPT, VERSION 1.0
  3.         POWERIMG.EXE
  4.         COPYRIGHT@2016~2018 BY HAPPY
  5.         LINK: -lgdi32 -lgdiplus -lole32 -lmsimg32
  6. */

  8. #include <stdio.h>
  9. #include <stdlib.h>
  10. #include <string.h>
  11. #include <ctype.h>
  12. #include <stdbool.h>
  13. #include <windows.h>
  14. #include <wincon.h>
  15. #include <gdiplus\gdiplus.h>
  16. #include <io.h>
  17. #include <conio.h>
  18. #include <math.h>
  19. #include <time.h>


  22. //定义π值
  23. #define M_PI 3.14159265358979323846

  25. //定义移位嵌套层数
  26. #define LOOP_LEVELS 16
  27. //限制解释关键词数量                        
  28. #define SENSITIVE_NUM 22
  29. //添加关键词(请用小写定义),解释时不区分大小写。
  30. static const char* KEY_WORDS[]={"add", "rot", "zom", "rev", "alp", "arg", "img", "slp", "lib", "jmp", "pos", "exi", "pau", "cls", "tit", "mod", "cot", "mvw", "cal", "eof", "ech", "cur"};

  32. //申明函数
  33. HWND    WINAPI GetConsoleWindow();
  34. BOOL    WINAPI AlphaBlend(HDC,int,int,int,int,HDC,int,int,int,int,BLENDFUNCTION);
  35. BOOL    WINAPI TransparentBlt(HDC,int,int,int,int,HDC,int,int,int,int,UINT);
  36. int     Drawgif(HWND hCMD, wchar_t* gifFile, int cmd_x,  int cmd_y, int size_W, int size_H, int CYCtimes, int playSpeed);
  37. int     FileScript(char* sfile, char* LIB_ARGS[16]);
  38. WCHAR*  AnsiToWCHAR(const char* str);


  41. //定义接收整形容器
  42. int   ATOI[16]={0};
  43. //定义旋转器
  44. int   ROTE[16]={0};
  45. //定义缩放器
  46. float ZOOM[16]={0};
  47. //定义反转器
  48. int   REVE[16]={0};
  49. //定义透明器
  50. int   ALPH[16]={0};

  52. //设主句柄
  53. HWND  hCMD;

  55. //图形结构体
  56. typedef struct{
  57.         HBITMAP hBitmap;
  58.         int Width;
  59.         int Height;
  60. }IMAGE;
  61. //整形结构体
  62. typedef struct{
  63.         int x;
  64.         int y;
  65. }RPOINT;
  66. //比率结构体
  67. typedef struct{
  68.         float x;
  69.         float y;
  70. }RATE;

  72. //移位结构体
  73. typedef struct{
  74.         long FTEL;
  75.         int  CYCL;
  76.         int  CADD;
  77.         int  LNUM;
  78.         //定义嵌套累加器
  79.         int  ADD[16];
  80. }fori;


  83. /***************图形函数群***************/
  84. //图形旋转
  85. int RotateDC(HDC hdc, int angle, RPOINT rpoint)  
  86. {
  87.         if(angle==0){return 1;}
  88.         XFORM Matrix;
  89.         double rad =-angle/180.0*M_PI;
  90.         Matrix.eM11 = (float)cos(rad);  
  91.         Matrix.eM12 = (float)sin(rad);  
  92.         Matrix.eM21 =-(float)sin(rad);  
  93.         Matrix.eM22 = (float)cos(rad);  
  94.         Matrix.eDx  = (float)(rpoint.x-cos(rad)*rpoint.x+sin(rad)*rpoint.y);  
  95.         Matrix.eDy  = (float)(rpoint.y-cos(rad)*rpoint.y-sin(rad)*rpoint.x);
  96.         SetGraphicsMode(hdc, GM_ADVANCED);
  97.         SetWorldTransform(hdc, &Matrix);
  98.         return 0;  
  99. }
  100. //图形缩放
  101. int ZoomDC(HDC hdc, RATE rate, RPOINT rpoint)  
  102. {
  103.         XFORM Matrix;
  104.         Matrix.eM11 = (float)rate.x;  
  105.         Matrix.eM12 = (float)0;  
  106.         Matrix.eM21 = (float)0;  
  107.         Matrix.eM22 = (float)rate.y;  
  108.         Matrix.eDx  = (float)(rpoint.x-rate.x*rpoint.x);  
  109.         Matrix.eDy  = (float)(rpoint.y-rate.y*rpoint.y);
  110.         SetGraphicsMode(hdc, GM_ADVANCED);
  111.         SetWorldTransform(hdc, &Matrix);
  112.         return 0;  
  113. }
  114. //图形反转
  115. int ReverseDC(HDC hdc, int reverse_mode, IMAGE img)
  116. {
  117.         XFORM Matrix;
  118.         if      (reverse_mode== 1){
  119.                 Matrix.eM11 =-(float)1;  
  120.                 Matrix.eM12 = (float)0;  
  121.                 Matrix.eM21 = (float)0;  
  122.                 Matrix.eM22 = (float)1;  
  123.                 Matrix.eDx  = (float)img.Width;  
  124.                 Matrix.eDy  = (float)0;       
  125.         }else if(reverse_mode== 2){
  126.                 Matrix.eM11 = (float)1;  
  127.                 Matrix.eM12 = (float)0;  
  128.                 Matrix.eM21 = (float)0;  
  129.                 Matrix.eM22 =-(float)1;  
  130.                 Matrix.eDx  = (float)0;  
  131.                 Matrix.eDy  = img.Height;
  132.         }else if(reverse_mode== 0){
  133.                 Matrix.eM11 =-(float)1;  
  134.                 Matrix.eM12 = (float)0;  
  135.                 Matrix.eM21 = (float)0;  
  136.                 Matrix.eM22 =-(float)1;  
  137.                 Matrix.eDx  = (float)img.Width;  
  138.                 Matrix.eDy  = (float)img.Height;
  139.         }else if(reverse_mode==-1){
  140.                 Matrix.eM11 = (float)0;  
  141.                 Matrix.eM12 = (float)1;  
  142.                 Matrix.eM21 = (float)1;  
  143.                 Matrix.eM22 = (float)0;  
  144.                 Matrix.eDx  = (float)0;  
  145.                 Matrix.eDy  = (float)0;
  146.         }else if(reverse_mode==-2){
  147.                 Matrix.eM11 = (float)0;  
  148.                 Matrix.eM12 = (float)1;  
  149.                 Matrix.eM21 =-(float)1;  
  150.                 Matrix.eM22 = (float)0;  
  151.                 Matrix.eDx  = (float)img.Height;  
  152.                 Matrix.eDy  = (float)0;
  153.         }
  154.         SetGraphicsMode(hdc, GM_ADVANCED);
  155.         SetWorldTransform(hdc, &Matrix);
  156.         return 0;  
  157. }
  158. //图形加载
  159. IMAGE LoadImg(char* imgFile, int _nWidth, int _nHeight)
  160. {
  161.         GpImage*     thisImage;
  162.         GpGraphics*  graphics=NULL;
  163.         ULONG_PTR    gdiplusToken;
  164.         IMAGE       _img;       
  165.         GdiplusStartupInput GSI={1, NULL, false, false};
  166.         HDC hdc=GetDC(NULL);
  167.         HDC hdcMem=CreateCompatibleDC(hdc);
  168.        
  169.         GdiplusStartup(&gdiplusToken, &GSI, NULL);   
  170.         GdipLoadImageFromFile(AnsiToWCHAR(imgFile), &thisImage);
  171.         GdipGetImageWidth(thisImage, &_img.Width);
  172.         GdipGetImageHeight(thisImage, &_img.Height);
  173.         if      (_nWidth !=0 && _nHeight==0){
  174.                 _img.Height=(int)( (_img.Height*1.0 / _img.Width) * (_nWidth ) );
  175.                 _img.Width =_nWidth;
  176.         }else if(_nWidth ==0 && _nHeight!=0){
  177.                 _img.Width =(int)( (_img.Width*1.0 / _img.Height) * (_nHeight) );
  178.                 _img.Height=_nHeight;
  179.         }else if(_nWidth !=0 && _nHeight!=0){
  180.                 _img.Width =_nWidth;
  181.                 _img.Height=_nHeight;
  182.         }
  183.         _img.hBitmap=CreateCompatibleBitmap(hdc, _img.Width, _img.Height);

  185.         SelectObject(hdcMem, _img.hBitmap);
  186.         GdipCreateFromHDC(hdcMem, &graphics);
  187.         GdipDrawImageRectI(graphics, thisImage, 0, 0, _img.Width, _img.Height);
  188.         GdipDisposeImage(thisImage);
  189.         GdipDeleteGraphics(graphics);
  190.         DeleteDC (hdcMem);
  191.         ReleaseDC(NULL, hdc);
  192.         GdiplusShutdown(gdiplusToken);
  193.         return _img;
  194. }
  195. //绘图函数
  196. int DrawImg(
  197.         char* imgfile,           //图形文件
  198.         int cmd_x,  int cmd_y,   //相对于cmd窗口位置
  199.         int size_W, int size_H,  //图片的显示宽高
  200.         int src_x,  int src_y,   //对相原图 截取位置
  201.         int disp_W, int disp_H,  //要显示多少宽高
  202.         fori* FORI[LOOP_LEVELS], //循环结构体指针
  203.         int KLevel               //循环层号
  204. ){

  206.         IMAGE P=LoadImg(imgfile, size_W, size_H);
  207.         HDC   hCUR=GetDC(hCMD);
  208.         HDC   hSRC=CreateCompatibleDC(hCUR);
  209.         SelectObject(hSRC, P.hBitmap);

  211.         if(ROTE[0]!=0){
  212.                 RPOINT rpoint={ROTE[1], ROTE[2]};
  213.                 RotateDC(hCUR, ROTE[3]+ROTE[0]*ROTE[4], rpoint);
  214.         }
  215.         if(ZOOM[0]!=0){
  216.                 RPOINT rpoint={(int)ZOOM[1], (int)ZOOM[2]};
  217.                 if(
  218.                         (ZOOM[3]+ZOOM[0]*ZOOM[5])<0 ||
  219.                         (ZOOM[4]+ZOOM[0]*ZOOM[6])<0
  220.                 ){
  221.                         return 1;
  222.                 }
  223.                 RATE rate={ZOOM[3]+ZOOM[0]*ZOOM[5], ZOOM[4]+ZOOM[0]*ZOOM[6]};
  224.                 ZoomDC(hCUR, rate, rpoint);
  225.         }
  226.         if(REVE[0]!=0){
  227.                 ReverseDC(hCUR, REVE[1], P);
  228.         }
  229.         if(FORI[KLevel]->ADD[0]!=0){
  230.                 int i=0;
  231.                 for(i=0; i<=KLevel; i++){
  232.                         cmd_x +=FORI[i]->ADD[0] * FORI[i]->ADD[1], cmd_y += FORI[i]->ADD[0] * FORI[i]->ADD[2];
  233.                         size_W+=FORI[i]->ADD[0] * FORI[i]->ADD[3], size_H+= FORI[i]->ADD[0] * FORI[i]->ADD[4];
  234.                         src_x +=FORI[i]->ADD[0] * FORI[i]->ADD[5], src_y += FORI[i]->ADD[0] * FORI[i]->ADD[6];
  235.                         disp_W+=FORI[i]->ADD[0] * FORI[i]->ADD[7], disp_H+= FORI[i]->ADD[0] * FORI[i]->ADD[8];
  236.                 }
  237.         }
  238.         disp_W=(disp_W<=0) ?P.Width  :disp_W;
  239.         disp_H=(disp_H<=0) ?P.Height :disp_H;

  241.         if      (ALPH[0]==1 && ALPH[1]==1){
  242.                 TransparentBlt(hCUR, cmd_x, cmd_y, disp_W, disp_H, hSRC, src_x, src_y, P.Width, P.Height, RGB(ALPH[2],ALPH[3],ALPH[4]));
  243.         }else if(ALPH[0]==1 && ALPH[1]==0){
  244.                 BLENDFUNCTION blendFunction={0, 0, (ALPH[2]==0)?-1:ALPH[2], 1};
  245.                 AlphaBlend(hCUR, cmd_x, cmd_y, disp_W, disp_H, hSRC, src_x, src_y, P.Width, P.Height, blendFunction);
  246.         }else if(ALPH[0]==0){
  247.                 BitBlt(hCUR, cmd_x, cmd_y, disp_W, disp_H, hSRC, src_x, src_y, SRCCOPY);
  248.         }

  250.         ROTE[0]=ZOOM[0]=REVE[0]=ALPH[0]=0;
  251.         FORI[KLevel]->ADD[0]=0;
  252.         DeleteObject(P.hBitmap);
  253.         ReleaseDC(hCMD, hCUR);
  254.         DeleteDC(hSRC);
  255.         return 0;
  256. }
  257. //擦图函数
  258. int CleanImg(
  259.         HWND  hd,                   //句柄
  260.         LONG  cmd_x,  LONG  cmd_y,  //起始擦除点，相对于cmd窗口位置的
  261.         LONG  size_W, LONG  size_H, //要擦除的宽高尺寸
  262.         BOOL  mode,
  263.         fori* FORI[LOOP_LEVELS],    //循环结构体指针
  264.         int KLevel                  //循环层号
  265. ){
  266.         RECT  z={cmd_x+FORI[KLevel]->ADD[0]*FORI[KLevel]->ADD[1], cmd_y+FORI[KLevel]->ADD[0]*FORI[KLevel]->ADD[2], cmd_x+size_W+FORI[KLevel]->ADD[0]*FORI[KLevel]->ADD[3], cmd_y+size_H+FORI[KLevel]->ADD[0]*FORI[KLevel]->ADD[4]};
  267.         if(mode){
  268.                 InvalidateRect(hd, &z, FALSE);
  269.         }else{
  270.                 InvalidateRect(hd, NULL, FALSE);
  271.         }
  272.         return 0;
  273. }


  276. /***************功能函数群***************/
  277. //子串查找，忽略大小写
  278. char* stristr(const char* str1, const char* str2)
  279. {
  280.         char* cp=(char *)str1;
  281.         char* s1, *s2;
  282.         if(!*str2){return (char *)str1;}
  283.         while(*cp){
  284.                 s1=cp;
  285.                 s2=(char *)str2;

  287.                 while(
  288.                         *s1 &&
  289.                         *s2 &&
  290.                         !(_tolower(*s1)-_tolower(*s2))
  291.                 ){s1++, s2++;}

  293.                 if (!*s2){return cp;}
  294.                 cp++;
  295.         }
  296.         return NULL;
  297. }
  298. //转码函数
  299. WCHAR* AnsiToWCHAR(const char* str)
  300. {
  301.         if(!str){return NULL;}
  302.         int wLen=MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, str, -1, NULL, 0);
  303.         WCHAR* wstr=(WCHAR*)malloc(sizeof(WCHAR)*wLen + 1);
  304.         MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, str, -1, wstr, wLen);
  305.         wstr[wLen]='\0';
  306.         return wstr;
  307. }
  308. //显示光标
  309. void DispyCursor(int size,bool mode)
  310. {       
  311.         CONSOLE_CURSOR_INFO cursor_info ={(DWORD)size, mode};
  312.         SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cursor_info);
  313.         return;
  314. }
  315. //移动光标
  316. int SetPos(int x,int y)
  317. {
  318.         COORD pos;
  319.         HANDLE hOutput;
  320.         pos.X=x, pos.Y=y;
  321.         hOutput=GetStdHandle(STD_OUTPUT_HANDLE);
  322.         SetConsoleCursorPosition(hOutput,pos);
  323.         return 0;
  324. }
  325. //测空字符
  326. inline bool isNULL(const char c){
  327.         if(
  328.                 c=='\t' ||
  329.                 c==' '  ||
  330.                 c=='\r' ||
  331.                 c=='\n' ||
  332.                 c=='\0'

  334.         ){
  335.                 return true;
  336.         }
  337.         return false;
  338. }
  339. //过滤行TAB缩进或前空格
  340. char* passNULL(char* Str){
  341.         if(Str!=NULL){
  342.                 while(*Str=='\t' ||*Str==' '){Str++;}
  343.         }
  344.         return Str;
  345. }
  346. //切分参数
  347. int args(char* Str, char* delims, char* ARGS[16], char* LIB_ARGS[16])
  348. {
  349.         int i=0;
  350.         char* p;
  351.         ARGS[i]=strtok(Str, delims);
  352.         while(ARGS[i]!=NULL){
  353.                 if( (p=stristr(ARGS[i], "*"))!=NULL){
  354.                         ARGS[i]=LIB_ARGS[atoi(p+1)];
  355.                 }
  356.                 ARGS[++i]=strtok(NULL, delims);
  357.         }       
  358.         return i;
  359. }
  360. //整化参数
  361. int ATOIargs(int* taner, int MAX_ARGC, int add, char* ARGS[16])
  362. {
  363.         int j;
  364.         for(j=0; j<16; j++){taner[j]=0;}
  365.         for(j=0; j<MAX_ARGC; j++){       
  366.                 taner[j+add]=atoi(ARGS[j]);
  367.         }
  368.         return 0;
  369. }
  370. //关键词解析函数
  371. int Identify_KeyWords(const char* Line)
  372. {
  373.         int i, SN;
  374.         for(SN=0; SN<SENSITIVE_NUM; SN++){
  375.                 for(i=0; KEY_WORDS[SN][i]!='\0'; i++){
  376.                         if(
  377.                                  Line[i]   !=KEY_WORDS[SN][i] &&
  378.                                  Line[i]+32!=KEY_WORDS[SN][i]
  379.                                 
  380.                         ){
  381.                                 break;
  382.                         }
  383.                 }
  384.                  if(
  385.                          KEY_WORDS[SN][i]=='\0' &&
  386.                         isNULL(Line[i])
  387.                 ){
  388.                         return SN;
  389.                 }
  390.         }                               
  391.         return 255;
  392. }

  394. //绘图函数
  395. int Shell_IMG(char* imgfile, fori* FORI[LOOP_LEVELS], int KLevel, int LineNUM)
  396. {
  397.         //为空则表示擦除
  398.         if(
  399.                 imgfile==NULL      ||
  400.                 isNULL(imgfile[0])
  401.         ){
  402.                         if(ATOI[0]==0){
  403.                                 CleanImg(hCMD, 0, 0, 0, 0, FALSE, FORI, KLevel);
  404.                         }else{
  405.                                 CleanImg(hCMD, ATOI[1], ATOI[2], ATOI[3], ATOI[4], TRUE, FORI, KLevel);
  406.                         }

  408.         //否则为图片显示
  409.         }else{
  410.                 if(access(imgfile, 0)==-1){
  411.                         fprintf(stdout, "[%d]:图片不存在。\n", LineNUM);
  412.                         exit(1);
  413.                 }
  414.                 DrawImg(imgfile,  ATOI[1], ATOI[2], ATOI[3], ATOI[4], ATOI[5], ATOI[6], ATOI[7], ATOI[8], FORI, KLevel);
  415.         }
  416.         return 0;
  417. }


  420. /***************Shell函数群***************/
  421. //清屏函数
  422. int Shell_CLS()
  423. {
  424.         HANDLE hConsole=GetStdHandle(STD_OUTPUT_HANDLE);
  425.         COORD coordScreen={0,0};
  426.         DWORD cCharsWritten;
  427.         CONSOLE_SCREEN_BUFFER_INFO csbi;
  428.         GetConsoleScreenBufferInfo(hConsole, &csbi);
  429.         FillConsoleOutputCharacter(hConsole,       (TCHAR)' ', csbi.dwSize.X*csbi.dwSize.Y, coordScreen, &cCharsWritten);
  430.         GetConsoleScreenBufferInfo(hConsole, &csbi);
  431.         FillConsoleOutputAttribute(hConsole, csbi.wAttributes, csbi.dwSize.X*csbi.dwSize.Y, coordScreen, &cCharsWritten);
  432.         SetConsoleCursorPosition(hConsole,coordScreen);
  433.         return 0;
  434. }
  435. //标题函数
  436. int Shell_TITLE(char* Str)
  437. {
  438.         SetConsoleTitle(Str);
  439.         return 0;
  440. }
  441. //按键函数
  442. int Shell_KEY(clock_t delay)
  443. {
  444.         int i,KEY_V,start=clock();
  445.         do{
  446.                 if(kbhit()){
  447.                          KEY_V=(int)(getch());
  448.                         if(KEY_V<97){KEY_V+=32;}
  449.                         return KEY_V;
  450.                 }
  451.                 for(i=0;i<=50;i++);
  452.         }while((clock()-start)<delay);
  453.         return -1;
  454. }
  455. //鼠标点击函数：KEY_V取值1、2对应鼠标左右键点击；当取值为0时则隐藏光标；
  456. int Shell_MOUSE(int KEY_V)
  457. {
  458.         if(KEY_V==0){
  459.                 CONSOLE_CURSOR_INFO cursor_info={1,0};
  460.                 SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE),&cursor_info);
  461.                 return 0;
  462.         }
  463.         HANDLE StdIn=GetStdHandle(STD_INPUT_HANDLE);
  464.         DWORD  OrgMode, Res;
  465.         INPUT_RECORD InR;
  466.         GetConsoleMode(StdIn, &OrgMode);
  467.         SetConsoleMode(StdIn, OrgMode | ENABLE_WINDOW_INPUT |  ENABLE_MOUSE_INPUT);
  468.         for(;;){
  469.                 ReadConsoleInput(StdIn, &InR, 1, &Res);
  470.                 if(
  471.                         InR.Event.MouseEvent.dwEventFlags ==0  &&
  472.                         InR.Event.MouseEvent.dwButtonState==KEY_V
  473.                 ){
  474.                         SetConsoleMode(StdIn, OrgMode);
  475.                         return (InR.Event.MouseEvent.dwMousePosition.Y)*1000+(InR.Event.MouseEvent.dwMousePosition.X);
  476.                 }
  477.         }
  478. }
  479. //窗口大小
  480. int Shell_MODE_CON(int x, int y)
  481. {

  483.         HANDLE StdOut=GetStdHandle(STD_OUTPUT_HANDLE);
  484.         CONSOLE_SCREEN_BUFFER_INFO scbi;
  485.         COORD size={x, 300};
  486.         GetConsoleScreenBufferInfo(StdOut, &scbi);
  487.         SetConsoleScreenBufferSize(StdOut, size);
  488.         SMALL_RECT rc={0, 0, x-1, y-1};
  489.         SetConsoleWindowInfo(StdOut, 1, &rc);
  490.         CloseHandle(StdOut);
  491.         return 0;
  492. }
  493. //字体颜色: 1,2,4,8前景；16,32,64,128后景；
  494. int Shell_COLOR(unsigned short A,unsigned short B,unsigned short C,unsigned short D)
  495. {
  496.         HANDLE handle_out = GetStdHandle(STD_OUTPUT_HANDLE);
  497.         CONSOLE_SCREEN_BUFFER_INFO csbi;
  498.         GetConsoleScreenBufferInfo(handle_out, &csbi);
  499.         SetConsoleTextAttribute(handle_out, A | B | C | D);
  500.         return 0;
  501. }
  502. //移动窗口
  503. int Shell_MW(int x, int y)
  504. {
  505.         HWND cmd=GetConsoleWindow();
  506.         SetWindowPos(cmd, HWND_TOP, x, y, 0, 0, SWP_NOSIZE);       
  507.         return 0;
  508. }


  511. /***************解析函数群***************/
  512. //脚本解析函数
  513. int FileScript(char* sfile, char* LIB_ARGS[16])
  514. {               
  515.         //初始参数 KLevel为当前循环层号；
  516.         int i=0, j=0, KLevel=0, Line_LEN=0, MAX_ARGC=0, SN=255;
  517.        
  518.         //读取脚本文件
  519.         FILE* fp;
  520.         if( (fp=fopen(sfile, "rb"))==NULL ){
  521.                 fprintf(stdout, "[%d]:读取文件失败。\n", i);
  522.                 exit(1);
  523.         }
  524.        
  525.         //初始化开关参数，SFLAG[0]==1开始； SFLAG[1]==1跳转； SFLAG[2]==1 呼叫归位；
  526.         int* SFLAG=(int*)calloc(8, sizeof(int));
  527.        
  528.         //初始化循环结构体
  529.         fori* FORI[LOOP_LEVELS];
  530.         for(j=0; j<LOOP_LEVELS; j++){
  531.                 FORI[j]=(fori*)calloc(1, sizeof(FORI));
  532.                 FORI[j]->FTEL=(long)0;
  533.                 FORI[j]->CYCL=0;
  534.                 FORI[j]->LNUM=0;
  535.                 FORI[j]->CADD=0;
  536.                 FORI[j]->ADD[16]=(int)calloc(16, sizeof(int));
  537.         }
  538.        
  539.         //定义切分字串容器
  540.         char* ARGS[16];       
  541.         for(j=0; j<16; j++){
  542.                 ARGS[j]=(char*)calloc(128, sizeof(char*));
  543.         }
  544.        
  545.         //分配行容器
  546.         char* LCache=(char*)calloc(1025, sizeof(char));
  547.         //辅助行指针
  548.         char* Line;

  550.         //标签跳转指针
  551.         char* JMP_MARK=(char*)malloc(128*sizeof(char));
  552.         //标签呼叫指针
  553.         long  CAL_MARK;

  555.         while(!feof(fp)){
  556.                 memset(LCache, 0,  1024*sizeof(char));
  557.                 fgets(LCache, 1024, fp);

  559.                 //指针置换
  560.                 Line=LCache;

  562.                 //行计数器
  563.                 i++;

  565.                 //过滤行TAB缩进或前空格
  566.                 while(*Line=='\t'|| *Line==' '){Line++;}

  568.                 //过滤注释符
  569.                 if(Line[0]=='/' &&Line[1]=='/'){
  570.                         continue;
  571.                 }
  572.                 //过滤段间注释符
  573.                 if(
  574.                         (Line[0]=='/' &&Line[1]=='*' )
  575.                 ){
  576.                         SFLAG[0]=0;
  577.                         continue;
  578.                        
  579.                 }else if(
  580.                         (Line[0]=='*' &&Line[1]=='/' )
  581.                 ){
  582.                         SFLAG[0]=1;
  583.                         continue;
  584.                        
  585.                 }else if(Line[0]=='#'){
  586.                         if(SFLAG[1]==0){
  587.                                 continue;               
  588.                         }else{
  589.                                 j=0;
  590.                                 while(
  591.                                         JMP_MARK[j]==Line[j] ||
  592.                                         JMP_MARK[j]==Line[j]-32
  593.                                 ){j++;}
  594.                                 if( isNULL(JMP_MARK[j]) && isNULL(Line[j]) ){SFLAG[1]=0;}
  595.                                 continue;
  596.                         }
  597.                 }

  599.                 //识别自然宏
  600.                 if(
  601.                         (Line[0]=='|') &&
  602.                         (Line[1]=='|')
  603.                 ){
  604.                         if(
  605.                                 stristr(Line+2, "start"  )!=NULL ||
  606.                                 stristr(Line+2, "begin"  )!=NULL ||
  607.                                 stristr(Line+2, "run"    )!=NULL
  608.                         ){
  609.                                 SFLAG[0]=1;
  610.                                 continue;
  611.                         }

  613.                         if(
  614.                                 stristr(Line+2, "end"    )!=NULL ||
  615.                                 stristr(Line+2, "eof"    )!=NULL
  616.                         ){
  617.                                 return 0;
  618.                         }

  620.                         if(
  621.                                 stristr(Line+2, "desktop")!=NULL ||
  622.                                 stristr(Line+2, "desk"   )!=NULL
  623.                         ){
  624.                                 hCMD=GetDesktopWindow();
  625.                                 continue;
  626.                         }

  628.                         if(
  629.                                 stristr(Line+2, "hide"   )!=NULL
  630.                         ){
  631.                                 DispyCursor(25, FALSE);
  632.                         }
  633.                         continue;
  634.                 }               

  636.                 //开始开关未打开，或遇到空行，或正在执行JMP跳转，则跳过该行
  637.                 if(
  638.                         SFLAG[0]==0     ||
  639.                         isNULL(Line[0]) ||
  640.                         SFLAG[1]==1
  641.                 ){continue;}
  642.                
  643.                 //解析循环开始标签
  644.                 if(
  645.                         (Line[0]=='['   ) &&
  646.                         (isNULL(Line[1])) //为空则开始循环
  647.                 ){
  648.                         FORI[++KLevel]->FTEL=ftell(fp);
  649.                         FORI[KLevel]->CYCL=0;
  650.                         FORI[KLevel+1]->CADD=0;
  651.                         FORI[KLevel]->LNUM=i+1;
  652.                         continue;
  653.                 }

  655.                 //解析循环结束标签
  656.                 if(Line[0]==']'){

  658.                         (FORI[KLevel]->CYCL)++;
  659.                         int TIM=atoi(strtok(Line+1,","));

  661.                         //移位器嵌套增量
  662.                         FORI[KLevel+1]->CADD=atoi(strtok(NULL,  ","));

  664.                         if      ( FORI[KLevel]->CYCL <  TIM+(FORI[KLevel]->CADD)*(FORI[KLevel-1]->CYCL) ){
  665.                                 fseek(fp, FORI[KLevel]->FTEL, SEEK_SET);
  666.                                 i=FORI[KLevel]->LNUM-1;

  668.                         }else if( FORI[KLevel]->CYCL >= TIM+(FORI[KLevel]->CADD)*(FORI[KLevel-1]->CYCL) ){
  669.                                 FORI[KLevel--]->CYCL=0;
  670.                         }
  671.                         continue;
  672.                 }
  673.                 //过滤回车符
  674.                 if((Line_LEN=strlen(Line))==2){
  675.                         continue;
  676.                 }else{
  677.                         Line[Line_LEN-2]='\0';
  678.                 }
  679.                 //解析命令行
  680.                 switch(Identify_KeyWords(Line)){
  681.                 case 0:
  682.                         //累加器
  683.                         MAX_ARGC=args(Line+4, " ", ARGS, LIB_ARGS);
  684.                         ATOIargs(FORI[KLevel]->ADD, MAX_ARGC, 1, ARGS);
  685.                         FORI[KLevel]->ADD[0]=FORI[KLevel]->CYCL+1;
  686.                         break;
  687.                 case 1:
  688.                         //旋转器
  689.                         MAX_ARGC=args(Line+4, " ", ARGS, LIB_ARGS);
  690.                         ATOIargs(ROTE, MAX_ARGC, 1, ARGS);
  691.                         ROTE[0]=FORI[KLevel]->CYCL+1;
  692.                         break;
  693.                 case 2:
  694.                         //缩放器
  695.                         MAX_ARGC=args(Line+4, " ", ARGS, LIB_ARGS);
  696.                         for(j=0; j<MAX_ARGC; j++){ ZOOM[j+1]=atof(ARGS[j]);}
  697.                         ZOOM[0]=FORI[KLevel]->CYCL+1;
  698.                         break;
  699.                 case 3:
  700.                         //反转器
  701.                         MAX_ARGC=args(Line+4, " ", ARGS, LIB_ARGS);
  702.                         ATOIargs(REVE, MAX_ARGC, 1, ARGS);
  703.                         REVE[0]=FORI[KLevel]->CYCL+1;
  704.                         break;
  705.                 case 4:
  706.                         //透明器
  707.                         MAX_ARGC=args(Line+4, " ", ARGS, LIB_ARGS);
  708.                         ATOIargs(ALPH, MAX_ARGC, 1, ARGS);
  709.                         ALPH[0]=1;
  710.                         break;
  711.                 case 5:
  712.                         //参数器
  713.                         MAX_ARGC=args(Line+4, " ", ARGS, LIB_ARGS);
  714.                         ATOIargs(ATOI, MAX_ARGC, 1, ARGS);
  715.                         ATOI[0]=1;
  716.                         break;
  717.                 case 6:
  718.                         //绘图器
  719.                         MAX_ARGC=args(Line+4, " ", ARGS, LIB_ARGS);
  720.                         Shell_IMG(passNULL(ARGS[0]), FORI, KLevel, i);
  721.                         break;
  722.                 case 7:
  723.                         //延时毫秒
  724.                         Sleep(atoi(Line+4));
  725.                         break;
  726.                 case 8:
  727.                         //调用LIB脚本库
  728.                         Line=passNULL(Line+4);
  729.                         if(Line[0]=='|'&&Line[1]=='|'){
  730.                                 MAX_ARGC=args(Line+2, "|", ARGS, LIB_ARGS);
  731.                                 FileScript(ARGS[0], ARGS);
  732.                         }else{
  733.                                 fprintf(stdout, "[%d]:缺少库名。\n", i);
  734.                                 exit(1);                       
  735.                         }

  737.                         break;
  738.                 case 9:
  739.                         //跳转器                       
  740.                         strcpy(JMP_MARK, strupr(passNULL(Line+4)));
  741.                         i=KLevel=i=SFLAG[0]=0, SFLAG[1]=1;
  742.                         fseek(fp, 0, SEEK_SET);
  743.                         break;
  744.                 case 10:
  745.                         //移动光标
  746.                         if(args(Line+4, " ", ARGS, LIB_ARGS) >1){SetPos(atoi(ARGS[0]), atoi(ARGS[1]));}
  747.                         break;
  748.                 case 11:
  749.                         //退出
  750.                         exit( atoi(Line+4) );
  751.                         break;
  752.                 case 12:
  753.                         //暂停
  754.                         getch();
  755.                         break;
  756.                 case 13:
  757.                         //清屏
  758.                         Shell_CLS();
  759.                         break;
  760.                 case 14:
  761.                         //标题
  762.                         SetConsoleTitle(Line+4);
  763.                         break;
  764.                 case 15:
  765.                         //窗口尺寸
  766.                         if( args(Line+4, " ", ARGS, LIB_ARGS) >1){Shell_MODE_CON(atoi(ARGS[0]), atoi(ARGS[1]));}
  767.                         break;
  768.                 case 16:
  769.                         //字体颜色
  770.                         if( args(Line+4, " ", ARGS, LIB_ARGS) >3){Shell_COLOR(atoi(ARGS[0]), atoi(ARGS[1]), atoi(ARGS[2]), atoi(ARGS[3]));}
  771.                         break;
  772.                 case 17:
  773.                         //移动窗口
  774.                         if( args(Line+4, " ", ARGS, LIB_ARGS) >1){Shell_MW(atoi(ARGS[0]), atoi(ARGS[1]));}
  775.                         break;
  776.                 case 18:
  777.                         //呼叫器
  778.                         CAL_MARK=ftell(fp);
  779.                         SFLAG[2]=1;
  780.                         strcpy(JMP_MARK, strupr(passNULL(Line+4)));
  781.                         i=KLevel=i=SFLAG[0]=0, SFLAG[1]=1;
  782.                         fseek(fp, 0, SEEK_SET);
  783.                         break;
  784.                 case 19:
  785.                         //EOF结尾标签
  786.                         if(SFLAG[2]==1){
  787.                                 fseek(fp, CAL_MARK, SEEK_SET);
  788.                                 SFLAG[2]==0;
  789.                         }else{
  790.                                 return 0;
  791.                         }
  792.                         break;
  793.                 case 20:
  794.                         //字符显示函数
  795.                         fputs(Line+4,stdout);
  796.                         fputs("\r\n",stdout);
  797.                         break;
  798.                 case 21:
  799.                         //设置光标尺寸
  800.                         DispyCursor(atoi(Line+4), TRUE);
  801.                         break;
  802.                 case 255:
  803.                         fprintf(stdout, "[%d]:错误指令。\n", i);
  804.                         exit(1);
  805.                         break;
  806.                 }
  807.         }
  808.         free(SFLAG);
  809.         free(FORI);
  810.         free(LCache);
  811.         fclose(fp);
  812.         return 0;
  813. }


  816. /*************MAIN主函数入口*************/
  817. int main(int argc, char** argv)
  818. {
  819.         if(argc==2){
  820.                 //获得控制台窗口句柄
  821.                 hCMD=GetConsoleWindow();
  822.                 char* LIB_ARGS[16];
  823.                 FileScript(argv[1], LIB_ARGS);
  824.                 return 0;
  825.         }

  827.         //异常则抛出使用说明
  828.         fputs(
  829.                 "THE CONSOLE DISPLAYS A PICTURE SCRIPT, COPYRIGHT@2016~2018 BY HAPPY\n"
  830.                 "VERSION 1.0\n"
  831.                 "usage: powerimg [scriptfile]\n"
  832.                 ,stdout
  833.         );
  834.         return 1;
  835. }
复制代码
回复

举报

zhangzsky
发表于 2016-11-28 13:51:40 | 显示全部楼层
楼主是第三方专业户了，很好很强大
回复

举报

zhangzsky
发表于 2016-11-29 02:01:07 | 显示全部楼层
回复 3# happy886rr

我只是打发下时间，感谢你的意见。有空我去看看lua和html5
回复

举报

happy886rr
 楼主| 发表于 2016-11-29 09:14:49 | 显示全部楼层
回复 4# zhangzsky
如果你学了lua游戏开发的话，我想你会被其惊人的功能所震惊，这年头java都得借用lua。当年大话西游就是靠lua开发的。推荐你学学lua游戏制作，那可是一天就能搞出个三国志单机版。我都打算用lua 去做powerimg的解释器核心，但是迫于体积太大，lua有200KB之多。我的做第三方不愿体积超过30KB。
回复

举报

zhangzsky
发表于 2016-11-29 12:35:52 | 显示全部楼层
本帖最后由 zhangzsky 于 2016-11-29 12:39 编辑

回复 5# happy886rr


    起初我只是想偶尔学学bat，然后想着写点什么，后来上班的电脑上到处都是，我基本上就双击下……
所以空出来时间写个游戏什么的锻炼下批处理……
已经跟起初的想法有出入了，自己文化水平有限。看来lua得空就看看也好
回复

举报

happy886rr
 楼主| 发表于 2016-11-29 12:55:22 | 显示全部楼层
回复 6# zhangzsky
批处理的优势在于批量操作，批量调用exe。
你做游戏，需要的是高效的工具，需要多媒体接口，能播放声音，显示动态画面，能2.5D旋转，这些批处理都不能实现。我觉得你的游戏设计思想很不错，你不应该被工具所局限，用批处理你只能做出那种简单的逐帧动画，但是你学学真正的游戏开发技术，会让你获得新生。
回复

举报

CrLf
发表于 2017-1-7 17:06:55 | 显示全部楼层
求exe
回复

举报

gfwlxx
发表于 2018-5-8 08:02:50 | 显示全部楼层
你多大年纪了
我要把你写的所有的都重新写一份
我正在写一款万能p-code虚拟机，
大神，收徒弟嘛，请收下我的膝盖
pm给我联系方式
回复

举报

523066680
发表于 2018-5-8 09:44:50 | 显示全部楼层
回复 8# gfwlxx


    听说他物理很好。
回复

举报

liujingcheng
发表于 2020-4-22 08:59:09 | 显示全部楼层
编译不了，vs都不行，你这是设么鬼
回复

举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

Archiver|手机版|小黑屋|批处理之家 ( 渝ICP备10000708号 )

GMT+8, 2026-3-16 23:26 , Processed in 0.025943 second(s), 8 queries , File On.

Powered by Discuz! X3.5

© 2001-2026 Discuz! Team.

快速回复 返回顶部 返回列表