搬家首发!!!

其实从初一我就写过一些小型战斗的游戏,但是画面都太粗糙,代码也比较乱,也就是和两三个同学瞎玩,但自从观摩了PoPoQQQ大神的游戏,顿时产生了重新写一部游戏的冲动,于是各种上网查找各种码代码,也搞出了这么一款相对还算“精致”的小游戏,并且更新了几个版本,趁着博客搬家了发一下

Orz PQ大神:http://blog.csdn.net/popoqqq/article/details/47193903

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

<幸运方块>是一款简单策略类游戏

游戏目标:开方块,升级装备,运用技能,Attack掉对手!

注意:需要<conio.h>库,默认的界面是绿色的

  1. /*
  2. ###[<Lucky_Block>] ###
  3. 制作者:***CQzhangyu***
  4. 版本:1.1.3
  5. 版本新增:
  6. 新添加了职业系统,共分为 4 个职业(骑士、法师、弓箭手、牧师)
  7. 每个职业添加 10 个职业专属幸运方块
  8. 对原版本的BUG和部分幸运方块有所改动
  9. * 修复了跨系统出现的BUG
  10. */
  11. #include <time.h>
  12. #include <stdio.h>
  13. #include <string.h>
  14. #include <stdlib.h>
  15. #include <iostream>
  16. #include <conio.h>
  17. #include <windows.h>
  18. using namespace std;
  19. const int n=,m=,tot=,kittot=,maxhp=;
  20. int turn;
  21. int map[][],cx,cy,step,skilluse;
  22. int dir[][]={{-,},{,},{,-},{,}};
  23. struct player
  24. {
  25. int px,py;
  26. int hp,life;
  27. int kit;
  28. int armor,weapon,leftuse;
  29. }p[];
  30. int port(int np,int tx,int ty);
  31. void activate(int np,int tx,int ty);
  32. inline int min(int a,int b)
  33. {
  34. return a<b?a:b;
  35. }
  36. inline int abs(int a)
  37. {
  38. return a>?a:-a;
  39. }
  40. inline int R()
  41. {
  42. return (rand()*rand())^(rand()*rand());
  43. }
  44. inline void wait(int Time)
  45. {
  46. Sleep(*Time);
  47. }
  48. void pmenu()
  49. {
  50. system("cls");
  51. puts("\n\n\n\n □ □ □ □□□ □ □ □ □");
  52. puts(" □ □ □ □ □ □ □ □");
  53. puts(" □ □ □ □ □□ □");
  54. puts(" □ □ □ □ □□ □");
  55. puts(" □ □ □ □ □ □ □");
  56. puts(" □□□□ □□□□ □□□ □ □ □\n");
  57. puts(" □□□ □ □□ □□□ □ □");
  58. puts(" □ □ □ □ □ □ □ □");
  59. puts(" □□□ □ □ □ □ □□");
  60. puts(" □ □ □ □ □ □ □□");
  61. puts(" □ □ □ □ □ □ □ □");
  62. puts(" □□□ □□□□ □□ □□□ □ □\n");
  63. printf("\t\t\t\t");
  64. }
  65. void selectkit()
  66. {
  67. int i;
  68. char input;
  69. for(i=;i<=;i++)
  70. {
  71. while()
  72. {
  73. pmenu();
  74. printf("请P%d选择职业\n",i+);
  75. printf("\t\t[1]:骑士\t\t[2]:法师\n");
  76. printf("\t\t[3]:弓箭手\t\t[4]:牧师\n");
  77. input=getch();
  78. if(input>=''&&input<='')
  79. {
  80. p[i].kit=input-'';
  81. break;
  82. }
  83. }
  84. }
  85. }
  86. void makemap()
  87. {
  88. int i,j;
  89. for(i=;i<=;i++)
  90. {
  91. pmenu();
  92. puts(">地图生成中<");
  93. printf("\t\t\t");
  94. for(j=;j<=i;j++)
  95. printf("■");
  96. for(j=i+;j<=;j++)
  97. printf("□");
  98. wait();
  99. }
  100. for(i=;i<=n;i++)
  101. for(j=;j<=m;j++)
  102. if((i^j)&)
  103. map[i][j]=R()%(tot+kittot)+;
  104. map[][]=map[n][m]=;
  105. }
  106. void setplayer()
  107. {
  108. int i;
  109. p[].px=p[].py=;
  110. p[].px=n;
  111. p[].py=m;
  112. for(i=;i<=;i++)
  113. {
  114. p[i].hp=maxhp;
  115. p[i].life=;
  116. }
  117. }
  118. void pmap()
  119. {
  120. system("cls");
  121. int i,j;
  122. printf("\t\t╔");
  123. for(i=;i<=m;i++) printf("═");
  124. printf("╗\n");
  125. for(i=;i<=n;i++)
  126. {
  127. printf("\t\t║");
  128. for(j=;j<=m;j++)
  129. {
  130. if(p[].px==i&&p[].py==j){ printf("P1"); continue;}
  131. if(p[].px==i&&p[].py==j){ printf("P2"); continue;}
  132. if(cx==i&&cy==j)
  133. {
  134. if(map[i][j]>) printf("■");
  135. else printf("+");
  136. continue;
  137. }
  138. if(map[i][j]>) printf("□");
  139. if(map[i][j]==) printf("·");
  140. }
  141. printf("║\n");
  142. }
  143. printf("\t\t╚");
  144. for(i=;i<=m;i++) printf("═");
  145. printf("╝\n");
  146. for(i=;i<=;i++){
  147. if(turn==i) printf(">"); else printf(" ");
  148. printf("P%d",i+);
  149. switch(p[i].kit){
  150. case :printf("[骑士]"); break;
  151. case :printf("[法师]"); break;
  152. case :printf("[弓箭手]"); break;
  153. case :printf("[牧师]"); break;
  154. }
  155. printf("\t生命x%d 血量:%d 护甲:%d 武器:%d(%d)\n",p[i].life-,p[i].hp,p[i].armor,p[i].weapon,p[i].leftuse);
  156. }
  157. }
  158. int resplayer(int np)
  159. {
  160. pmap();
  161. printf("P%d死亡!\n",np+);
  162. wait();
  163. p[np].life--;
  164. p[np].armor=p[np].weapon=p[np].leftuse=;
  165. p[np].hp=maxhp;
  166. if(p[np].life<=)
  167. return ;
  168. if(np==)
  169. port(np,,);
  170. if(np==)
  171. port(np,n,m);
  172. pmap();
  173. printf("P%d已复活!\n",np+);
  174. wait();
  175. return ;
  176. }
  177. int getweapon(int np,int watk,int wlft)
  178. {
  179. char input;
  180. while(p[np].leftuse>)
  181. {
  182. pmap();
  183. printf("P%d已装备武器,是否替换?(y/n)",np+);
  184. input=getch();
  185. if(input=='Y'||input=='y')
  186. {
  187. p[np].weapon=watk;
  188. p[np].leftuse=wlft;
  189. return ;
  190. }
  191. if(input=='N'||input=='n')
  192. return ;
  193. }
  194. p[np].weapon=watk;
  195. p[np].leftuse=wlft;
  196. return ;
  197. }
  198. int damage(int np,int val)
  199. {
  200. pmap();
  201. printf("P%d受到了%d点伤害!\n",np+,val);
  202. wait();
  203. if(p[np].armor>)
  204. {
  205. p[np].armor-=val;
  206. if(p[np].armor<)
  207. {
  208. p[np].hp+=p[np].armor;
  209. p[np].armor=;
  210. }
  211. }
  212. else
  213. p[np].hp-=val;
  214. if(p[np].hp<=)
  215. if(resplayer(np))
  216. return ;
  217. return ;
  218. }
  219. void block1(int np)
  220. {
  221. pmap();
  222. puts("╔╦╗----【闪电】----");
  223. puts("╠?╣~对自己造成 3 点伤害。");
  224. puts("╚╩╝");
  225. wait();
  226. damage(np,);
  227. }
  228. void block2(int np)
  229. {
  230. pmap();
  231. puts("╔╦╗----【草莓蛋糕】----");
  232. puts("╠?╣~为自己恢复 3 点血量。");
  233. puts("╚╩╝");
  234. wait();
  235. p[np].hp=min(p[np].hp+,maxhp);
  236. }
  237. void block3(int np)
  238. {
  239. pmap();
  240. puts("╔╦╗----【木质弓箭】----");
  241. puts("╠?╣~对敌人造成 2 点伤害。");
  242. puts("╚╩╝");
  243. wait();
  244. damage(np^,);
  245. }
  246. void block4(int np)
  247. {
  248. pmap();
  249. puts("╔╦╗----【逗你玩宝箱】----");
  250. puts("╠?╣~什么都没有发生。");
  251. puts("╚╩╝");
  252. wait();
  253. }
  254. void block5(int np)
  255. {
  256. pmap();
  257. puts("╔╦╗----【初阶匕首】----");
  258. puts("╠?╣~装备一把攻击力: 3 ,耐久: 2 的武器。");
  259. puts("╚╩╝");
  260. wait();
  261. getweapon(np,,);
  262. }
  263. void block6(int np)
  264. {
  265. pmap();
  266. puts("╔╦╗----【初阶皮甲】----");
  267. puts("╠?╣~获得 3 点护甲值。");
  268. puts("╚╩╝");
  269. wait();
  270. p[np].armor+=;
  271. }
  272. void block7(int np)
  273. {
  274. pmap();
  275. puts("╔╦╗\t----【整装待发】----");
  276. puts("╠?╣~装备一把攻击力: 2 ,耐久: 2 的武器;获得 2 点护甲值。");
  277. puts("╚╩╝");
  278. wait();
  279. getweapon(np,,);
  280. p[np].armor+=;
  281. }
  282. void block8(int np)
  283. {
  284. pmap();
  285. puts("╔╦╗\t----【装备升级】----");
  286. puts("╠?╣~使你的武器获得 +1 攻击力和 +1 耐久度;获得 1 点护甲值。");
  287. puts("╚╩╝");
  288. wait();
  289. if(p[np].leftuse>)
  290. {
  291. p[np].weapon++;
  292. p[np].leftuse++;
  293. }
  294. p[np].armor++;
  295. }
  296. void block9(int np)
  297. {
  298. pmap();
  299. puts("╔╦╗----【冰冻陷阱】----");
  300. puts("╠?╣~立刻结束本回合。");
  301. puts("╚╩╝");
  302. wait();
  303. if(np==turn)
  304. step=;
  305. }
  306. void block10(int np)
  307. {
  308. pmap();
  309. puts("╔╦╗----【天降甘霖】----");
  310. puts("╠?╣~为双方各恢复 4 点血量。");
  311. puts("╚╩╝");
  312. wait();
  313. p[].hp=min(p[].hp+,maxhp);
  314. p[].hp=min(p[].hp+,maxhp);
  315. }
  316. void block11(int np)
  317. {
  318. pmap();
  319. puts("╔╦╗----【幻影传送】----");
  320. puts("╠?╣~使你瞬间移动到一个随机的位置。");
  321. puts("╚╩╝");
  322. wait();
  323. while()
  324. {
  325. int tx=R()%n+,ty=R()%m+;
  326. if(tx!=p[np^].px||ty!=p[np^].py)
  327. {
  328. port(np,tx,ty);
  329. break;
  330. }
  331. }
  332. }
  333. void block12(int np)
  334. {
  335. pmap();
  336. puts("╔╦╗----【快速移动】----");
  337. puts("╠?╣~再掷一次骰子。");
  338. puts("╚╩╝");
  339. wait();
  340. if(np!=turn)
  341. return ;
  342. int ts=R()%+;
  343. pmap();
  344. printf("掷到了%d点!",ts);
  345. wait();
  346. step+=ts;
  347. }
  348. void block13(int np)
  349. {
  350. pmap();
  351. puts("╔╦╗----【精制短剑】----");
  352. puts("╠?╣~装备一把攻击力: 4 ,耐久: 3 的武器。");
  353. puts("╚╩╝");
  354. wait();
  355. getweapon(np,,);
  356. }
  357. void block14(int np)
  358. {
  359. pmap();
  360. puts("╔╦╗----【精制铁甲】----");
  361. puts("╠?╣~获得 5 点护甲值。");
  362. puts("╚╩╝");
  363. wait();
  364. p[np].armor+=;
  365. }
  366. void block15(int np)
  367. {
  368. pmap();
  369. puts("╔╦╗----【幸运虹光】----");
  370. puts("╠?╣~双方各触发一次随机幸运方块效果。");
  371. puts("╚╩╝");
  372. wait();
  373. map[p[np].px][p[np].py]=R()%(tot+kittot)+;
  374. activate(np,p[np].px,p[np].py);
  375. map[p[np^].px][p[np^].py]=R()%(tot+kittot)+;
  376. activate(np^,p[np^].px,p[np^].py);
  377. }
  378. void block16(int np)
  379. {
  380. pmap();
  381. puts("╔╦╗----【圣洁之露】----");
  382. puts("╠?╣~为自己恢复所有血量。");
  383. puts("╚╩╝");
  384. wait();
  385. p[np].hp=maxhp;
  386. }
  387. void block17(int np)
  388. {
  389. pmap();
  390. puts("╔╦╗\t----【恐怖恶魔】----");
  391. puts("╠?╣~对自己造成 4 点伤害;使你的武器失去 1 点耐久度。");
  392. puts("╚╩╝");
  393. wait();
  394. damage(np,);
  395. if(p[np].leftuse>)
  396. p[np].leftuse--;
  397. if(p[np].leftuse==)
  398. p[np].weapon=;
  399. }
  400. void block18(int np)
  401. {
  402. pmap();
  403. puts("╔╦╗----【穿刺炸弹】----");
  404. puts("╠?╣~对 11x11 内的所有角色造成 3 点伤害。");
  405. puts("╚╩╝");
  406. wait();
  407. damage(np,);
  408. if(abs(p[].px-p[].px)<=&&abs(p[].py-p[].py)<=)
  409. damage(np^,);
  410. }
  411. void block19(int np)
  412. {
  413. pmap();
  414. puts("╔╦╗----【王者对决】----");
  415. puts("╠?╣~立刻将对手移动到你的身边。");
  416. puts("╚╩╝");
  417. wait();
  418. if(p[np].px>)
  419. port(np^,p[np].px-,p[np].py);
  420. else
  421. port(np^,p[np].px+,p[np].py);
  422. }
  423. void block20(int np)
  424. {
  425. pmap();
  426. puts("╔╦╗----【正义之锤】----");
  427. puts("╠?╣~装备一把攻击力: 2 ,耐久: 5 的正义之锤。");
  428. puts("╚╩╝");
  429. wait();
  430. getweapon(np,,);
  431. }
  432. void block21(int np)
  433. {
  434. pmap();
  435. puts("╔╦╗----【灵魂之火】----");
  436. puts("╠?╣~使自己的血量变为: 5 。");
  437. puts("╚╩╝");
  438. wait();
  439. p[np].hp=;
  440. }
  441. void block22(int np)
  442. {
  443. pmap();
  444. puts("╔╦╗\t\t----【改装】----");
  445. puts("╠?╣~消耗掉所有护甲值;使你的武器获得 +2 攻击力。");
  446. puts("╚╩╝");
  447. wait();
  448. if(p[np].leftuse)
  449. {
  450. p[np].weapon+=;
  451. p[np].armor=;
  452. }
  453. }
  454. void block23(int np)
  455. {
  456. pmap();
  457. puts("╔╦╗\t\t----【精准掷击】----");
  458. puts("╠?╣~对对手造成等同于你武器攻击力的伤害,摧毁你的武器。");
  459. puts("╚╩╝");
  460. wait();
  461. if(p[np].leftuse)
  462. {
  463. damage(np^,p[np].weapon);
  464. p[np].weapon=p[np].leftuse=;
  465. }
  466. }
  467. void block24(int np)
  468. {
  469. pmap();
  470. puts("╔╦╗----【镜像反转】----");
  471. puts("╠?╣~交换你与对手的武器,护甲,血量值。");
  472. puts("╚╩╝");
  473. wait();
  474. swap(p[np].hp,p[np^].hp);
  475. swap(p[np].armor,p[np^].armor);
  476. swap(p[np].weapon,p[np^].weapon);
  477. swap(p[np].leftuse,p[np^].leftuse);
  478. }
  479. void block25(int np)
  480. {
  481. pmap();
  482. puts("╔╦╗----【沉重之甲】----");
  483. puts("╠?╣~获得 6 点护甲值,结束你的回合。");
  484. puts("╚╩╝");
  485. wait();
  486. p[np].armor+=;
  487. if(turn==np)
  488. step=;
  489. }
  490. void block26(int np)
  491. {
  492. pmap();
  493. puts("╔╦╗\t\t----【献祭】----");
  494. puts("╠?╣~消耗 4 点血量,装备一把攻击力: 5 ,耐久: 2 的血之复仇。");
  495. puts("╚╩╝");
  496. wait();
  497. p[np].hp-=;
  498. if(p[np].hp<=)
  499. {
  500. resplayer(np);
  501. return ;
  502. }
  503. getweapon(np,,);
  504. }
  505. void block27(int np)
  506. {
  507. pmap();
  508. puts("╔╦╗----【救赎】----");
  509. puts("╠?╣~获得 1 条生命,对自己造成 12 点伤害。");
  510. puts("╚╩╝");
  511. wait();
  512. p[np].life++;
  513. damage(np,);
  514. }
  515. void block28(int np)
  516. {
  517. pmap();
  518. puts("╔╦╗----【幸运风暴】----");
  519. puts("╠?╣~触发 3 次随机幸运方块效果。");
  520. puts("╚╩╝");
  521. wait();
  522. for(int i=;i<=;i++)
  523. {
  524. map[p[np].px][p[np].py]=R()%(tot+kittot)+;
  525. activate(np,p[np].px,p[np].py);
  526. }
  527. }
  528. void block29(int np)
  529. {
  530. pmap();
  531. puts("╔╦╗----【龙卷风】----");
  532. puts("╠?╣~清除所有角色的武器和护甲值。");
  533. puts("╚╩╝");
  534. wait();
  535. p[].armor=p[].weapon=p[].leftuse=;
  536. p[].armor=p[].weapon=p[].leftuse=;
  537. }
  538. void block30(int np)
  539. {
  540. pmap();
  541. puts("╔╦╗\t----【金色祝福】----");
  542. puts("╠?╣~双方各装备一把攻击力: 2 ,耐久: 3 的武器,各获得 3 点护甲值。");
  543. puts("╚╩╝");
  544. wait();
  545. getweapon(,,);
  546. getweapon(,,);
  547. p[].armor+=;
  548. p[].armor+=;
  549. }
  550. void block101(int np)
  551. {
  552. pmap();
  553. puts("╔╦╗----【正义之斧】----");
  554. puts("╠?╣~装备一把攻击力: 3 ,耐久: 3 的武器。");
  555. puts("╚╩╝");
  556. wait();
  557. getweapon(np,,);
  558. }
  559. void block102(int np)
  560. {
  561. pmap();
  562. puts("╔╦╗----【圣光战马】----");
  563. puts("╠?╣~获得 3 点护甲值,剩余移动次数 +3 。");
  564. puts("╚╩╝");
  565. wait();
  566. p[np].armor+=;
  567. if(np==turn)
  568. step+=;
  569. }
  570. void block103(int np)
  571. {
  572. pmap();
  573. puts("╔╦╗\t----【识破】----");
  574. puts("╠?╣~使对方武器攻击力和护甲值降为 2 。");
  575. puts("╚╩╝");
  576. wait();
  577. if(p[np^].leftuse)
  578. p[np^].weapon=;
  579. if(p[np^].armor>)
  580. p[np^].armor=;
  581. }
  582. void block104(int np)
  583. {
  584. pmap();
  585. puts("╔╦╗\t----【神圣祝福】----");
  586. puts("╠?╣~使你的武器攻击力 +1 ,耐久 +2 ,获得 2 点护甲值,");
  587. puts("╚╩╝如果你没有武器,则装备一把攻击力: 2 ,耐久: 2 的武器。");
  588. wait();
  589. if(p[np].leftuse)
  590. {
  591. p[np].weapon++;
  592. p[np].leftuse+=;
  593. }
  594. else getweapon(np,,);
  595. p[np].armor+=;
  596. }
  597. void block105(int np)
  598. {
  599. pmap();
  600. puts("╔╦╗----【光耀之甲】----");
  601. puts("╠?╣~清除你的武器,使你的护甲值变为 7 。");
  602. puts("╚╩╝");
  603. wait();
  604. if(p[np].leftuse)
  605. p[np].weapon=p[np].leftuse=;
  606. p[np].armor=;
  607. }
  608. void block106(int np)
  609. {
  610. pmap();
  611. puts("╔╦╗\t----【公平较量】----");
  612. puts("╠?╣~使你的武器与对手相同,对手的护甲值与你相同。");
  613. puts("╚╩╝");
  614. wait();
  615. p[np].weapon=p[np^].weapon;
  616. p[np].leftuse=p[np^].leftuse;
  617. p[np^].armor=p[np].armor;
  618. }
  619. void block107(int np)
  620. {
  621. pmap();
  622. puts("╔╦╗----【勇敢奉献】----");
  623. puts("╠?╣~消耗 1 点血量,对对方造成 3 点伤害。");
  624. puts("╚╩╝");
  625. wait();
  626. p[np].hp-=;
  627. if(p[np].hp<=)
  628. resplayer(np);
  629. damage(np^,);
  630. }
  631. void block108(int np)
  632. {
  633. pmap();
  634. puts("╔╦╗\t----【光明圣印】----");
  635. puts("╠?╣~获得 2 点护甲值,触发一次随机幸运方块效果。");
  636. puts("╚╩╝");
  637. wait();
  638. p[np].armor+=;
  639. map[p[np].px][p[np].py]=R()%(tot+kittot)+;
  640. activate(np,p[np].px,p[np].py);
  641. }
  642. void block109(int np)
  643. {
  644. pmap();
  645. puts("╔╦╗\t----【血蹄战马】----");
  646. puts("╠?╣~清除你的武器和护甲值,装备一把攻击力: 4 ,耐久: 2 的光之愤怒,");
  647. puts("╚╩╝剩余移动次数 +6");
  648. wait();
  649. p[np].weapon=p[np].leftuse=p[np].armor=;
  650. getweapon(np,,);
  651. if(turn==np)
  652. step+=;
  653. }
  654. void block110(int np)
  655. {
  656. pmap();
  657. puts("╔╦╗\t----【极耀之光】----");
  658. puts("╠?╣~对 17x17 内的敌人造成等同于你武器攻击力的伤害,");
  659. puts("╚╩╝使你的武器耐久 -1 。");
  660. wait();
  661. if(p[np].leftuse)
  662. {
  663. if(abs(p[].px-p[].px)<=&&abs(p[].py-p[].py)<=)
  664. damage(np^,p[np].weapon);
  665. p[np].leftuse--;
  666. if(p[np].leftuse<=)
  667. p[np].weapon=;
  668. }
  669. }
  670. void block201(int np)
  671. {
  672. pmap();
  673. puts("╔╦╗----【魔法飞弹】----");
  674. puts("╠?╣~对 17x17 内的敌人造成 3 点伤害。");
  675. puts("╚╩╝");
  676. wait();
  677. if(abs(p[].px-p[].px)<=&&abs(p[].py-p[].py)<=)
  678. damage(np^,);
  679. }
  680. void block202(int np)
  681. {
  682. pmap();
  683. puts("╔╦╗----【雷电之牢】----");
  684. puts("╠?╣~在对手周围生成 4 个[闪电]。");
  685. puts("╚╩╝");
  686. wait();
  687. int i,tx,ty;
  688. for(i=;i<;i++)
  689. {
  690. tx=p[np^].px+dir[i][];
  691. ty=p[np^].py+dir[i][];
  692. if(tx>=&&tx<=n&&ty>=&&ty<=m&&(tx!=p[np].px||ty!=p[np].py))
  693. map[tx][ty]=;
  694. }
  695. }
  696. void block203(int np)
  697. {
  698. pmap();
  699. puts("╔╦╗----【凝霜之息】----");
  700. puts("╠?╣~在对手周围生成 4 个[冰冻陷阱]。");
  701. puts("╚╩╝");
  702. wait();
  703. int i,tx,ty;
  704. for(i=;i<;i++)
  705. {
  706. tx=p[np^].px+dir[i][];
  707. ty=p[np^].py+dir[i][];
  708. if(tx>=&&tx<=n&&ty>=&&ty<=m&&(tx!=p[np].px||ty!=p[np].py))
  709. map[tx][ty]=;
  710. }
  711. }
  712. void block204(int np)
  713. {
  714. pmap();
  715. puts("╔╦╗----【暗能炸弹】----");
  716. puts("╠?╣~对对方 9x9 内的所有玩家造成 3 点伤害。");
  717. puts("╚╩╝");
  718. wait();
  719. damage(np^,);
  720. if(abs(p[].px-p[].px)<=&&abs(p[].py-p[].py)<=)
  721. damage(np,);
  722. }
  723. void block205(int np)
  724. {
  725. pmap();
  726. puts("╔╦╗----【魔能之火】----");
  727. puts("╠?╣~对对方造成 2~5 点伤害。");
  728. puts("╚╩╝");
  729. wait();
  730. damage(np^,R()%+);
  731. }
  732. void block206(int np)
  733. {
  734. pmap();
  735. puts("╔╦╗----【远古祝福】----");
  736. puts("╠?╣~使你的武器攻击力 +1 ,耐久 +4 ;获得 4 点护甲值。");
  737. puts("╚╩╝");
  738. wait();
  739. if(p[np].leftuse)
  740. {
  741. p[np].weapon++;
  742. p[np].leftuse+=;
  743. }
  744. p[np].armor+=;
  745. }
  746. void block207(int np)
  747. {
  748. pmap();
  749. puts("╔╦╗----【烈焰风暴】----");
  750. puts("╠?╣~对所有角色造成 4 点伤害。");
  751. puts("╚╩╝");
  752. wait();
  753. damage(np^,);
  754. damage(np,);
  755. }
  756. void block208(int np)
  757. {
  758. pmap();
  759. puts("╔╦╗\t----【风暴法杖】----");
  760. puts("╠?╣~装备一把攻击力: 2 ,耐久: 3 的武器,对对方造成 2 点伤害。");
  761. puts("╚╩╝");
  762. wait();
  763. damage(np^,);
  764. getweapon(np,,);
  765. }
  766. void block209(int np)
  767. {
  768. pmap();
  769. puts("╔╦╗\t----【远古魔法阵】----");
  770. puts("╠?╣~在你的周围生成 8 个幸运方块,剩余移动次数 +4。");
  771. puts("╚╩╝");
  772. wait();
  773. int i,j,tx,ty;
  774. for(i=-;i<=;i++)
  775. {
  776. for(j=-;j<=;j++)
  777. {
  778. tx=p[np].px+i;
  779. ty=p[np].py+j;
  780. if((i==&&j==)||tx<||tx>n||ty<||ty>m)
  781. continue;
  782. if(p[np^].px!=tx||p[np^].py!=ty)
  783. map[tx][ty]=R()%(tot+kittot)+;
  784. }
  785. }
  786. if(turn==np)
  787. step+=;
  788. }
  789. void block210(int np)
  790. {
  791. pmap();
  792. puts("╔╦╗\t----【星界魔法】----");
  793. puts("╠?╣~获得 2 点护甲值,在你的周围生成 4 个[魔法飞弹]。");
  794. puts("╚╩╝");
  795. wait();
  796. p[np].armor+=;
  797. int i,tx,ty;
  798. for(i=;i<;i++)
  799. {
  800. tx=p[np].px+dir[i][];
  801. ty=p[np].py+dir[i][];
  802. if(tx>=&&tx<=n&&ty>=&&ty<=m&&(tx!=p[np^].px||ty!=p[np^].py))
  803. map[tx][ty]=tot+;
  804. }
  805. }
  806. void block301(int np)
  807. {
  808. pmap();
  809. puts("╔╦╗----【强化弓箭】----");
  810. puts("╠?╣~对对方造成 3 点伤害,剩余移动次数 -1。");
  811. puts("╚╩╝");
  812. wait();
  813. damage(np^,);
  814. if(turn==np) step=max(step-,);
  815. }
  816. void block302(int np)
  817. {
  818. pmap();
  819. puts("╔╦╗----【快速射击】----");
  820. puts("╠?╣~对对方造成等同你武器耐久的伤害。");
  821. puts("╚╩╝");
  822. wait();
  823. if(p[np].leftuse)
  824. damage(np^,p[np].leftuse);
  825. }
  826. void block303(int np)
  827. {
  828. pmap();
  829. puts("╔╦╗----【远程狙击】----");
  830. puts("╠?╣~对 17x17 以外的敌人造成 4 点伤害。");
  831. puts("╚╩╝");
  832. wait();
  833. if(abs(p[].px-p[].px)>||abs(p[].py-p[].py)>)
  834. damage(np^,);
  835. }
  836. void block304(int np)
  837. {
  838. pmap();
  839. puts("╔╦╗----【武器打磨】----");
  840. puts("╠?╣~使你的武器攻击力 +2 ,耐久 -1 。");
  841. puts("╚╩╝");
  842. wait();
  843. if(p[np].leftuse)
  844. {
  845. p[np].weapon+=;
  846. p[np].leftuse--;
  847. if(!p[np].leftuse)
  848. p[np].weapon=;
  849. }
  850. }
  851. void block305(int np)
  852. {
  853. pmap();
  854. puts("╔╦╗----【穿甲弓箭】----");
  855. puts("╠?╣~使对方的血量 -2 。");
  856. puts("╚╩╝");
  857. wait();
  858. p[np^].hp-=;
  859. if(p[np^].hp<=)
  860. resplayer(np^);
  861. }
  862. void block306(int np)
  863. {
  864. pmap();
  865. puts("╔╦╗\t----【隐蔽】----");
  866. puts("╠?╣~获得 4 点护甲值,剩余移动次数 -2 。");
  867. puts("╚╩╝");
  868. wait();
  869. p[np].armor+=;
  870. if(turn==np)
  871. step-=;
  872. }
  873. void block307(int np)
  874. {
  875. pmap();
  876. puts("╔╦╗\t----【回旋镖】----");
  877. puts("╠?╣~对对方造成 1 点伤害,装备一把攻击力: 4 ,耐久: 1 的武器。");
  878. puts("╚╩╝");
  879. wait();
  880. damage(np^,);
  881. getweapon(np,,);
  882. }
  883. void block308(int np)
  884. {
  885. pmap();
  886. puts("╔╦╗\t----【追踪术】----");
  887. puts("╠?╣~剩余移动次数 +1 ,触发一次随机幸运方块效果。");
  888. puts("╚╩╝");
  889. wait();
  890. if(turn==np) step++;
  891. map[p[np].px][p[np].py]=R()%(tot+kittot)+;
  892. activate(np,p[np].px,p[np].py);
  893. }
  894. void block309(int np)
  895. {
  896. pmap();
  897. puts("╔╦╗\t----【风行术】----");
  898. puts("╠?╣~消耗所有护甲值,每消耗 1 点护甲值,。");
  899. puts("╚╩╝使你的剩余移动次数 +1 。");
  900. wait();
  901. if(turn==np)
  902. {
  903. step+=p[np].armor;
  904. p[np].armor=;
  905. }
  906. }
  907. void block310(int np)
  908. {
  909. pmap();
  910. puts("╔╦╗\t----【坚强意志】----");
  911. puts("╠?╣~获得 2 点护甲值,如果这不是你的回合,");
  912. puts("╚╩╝则改为获得 5 点护甲值。");
  913. wait();
  914. if(turn!=np) p[np].armor+=;
  915. else p[np].armor+=;
  916. }
  917. void block401(int np)
  918. {
  919. pmap();
  920. puts("╔╦╗----【圣洁之泉】----");
  921. puts("╠?╣~为自己恢复 4 点血量。");
  922. puts("╚╩╝");
  923. wait();
  924. p[np].hp=min(p[np].hp+,maxhp);
  925. }
  926. void block402(int np)
  927. {
  928. pmap();
  929. puts("╔╦╗----【治疗之环】----");
  930. puts("╠?╣~为 13x13 内的所有角色恢复 5 点血量。");
  931. puts("╚╩╝");
  932. wait();
  933. p[np].hp=min(p[np].hp+,maxhp);
  934. if(abs(p[].px-p[].px)<=&&abs(p[].py-p[].py)<=)
  935. p[np^].hp=min(p[np^].hp+,maxhp);
  936. }
  937. void block403(int np)
  938. {
  939. pmap();
  940. puts("╔╦╗----【生命汲取】----");
  941. puts("╠?╣~使对方血量 -2 ,为你恢复 2 点血量。");
  942. puts("╚╩╝");
  943. wait();
  944. p[np^].hp-=;
  945. if(p[np^].hp<=) resplayer(np^);
  946. p[np].hp=min(p[np].hp+,maxhp);
  947. }
  948. void block404(int np)
  949. {
  950. pmap();
  951. puts("╔╦╗----【控心术】----");
  952. puts("╠?╣~使对方的血量变为 5 。");
  953. puts("╚╩╝");
  954. wait();
  955. p[np^].hp=;
  956. }
  957. void block405(int np)
  958. {
  959. pmap();
  960. puts("╔╦╗----【血之契约】----");
  961. puts("╠?╣~如果你持有武器,使你的武器攻击力 +2 ,耐久 +3 ,并消耗 1 点生命值。");
  962. puts("╚╩╝");
  963. wait();
  964. if(p[np].leftuse)
  965. {
  966. p[np].weapon+=;
  967. p[np].leftuse+=;
  968. p[np].hp-=;
  969. if(p[np].hp<=)
  970. resplayer(np);
  971. }
  972. }
  973. void block406(int np)
  974. {
  975. pmap();
  976. puts("╔╦╗----【反噬】----");
  977. puts("╠?╣~使双方的血量变为 11-当前血量。");
  978. puts("╚╩╝");
  979. wait();
  980. p[].hp=-p[].hp;
  981. p[].hp=-p[].hp;
  982. }
  983. void block407(int np)
  984. {
  985. pmap();
  986. puts("╔╦╗\t----【圣光惩击】----");
  987. puts("╠?╣~对对方造成等同于其武器攻击力的伤害,");
  988. puts("╚╩╝使对方的武器耐久度 -1 。");
  989. wait();
  990. if(p[np^].leftuse)
  991. {
  992. damage(np^,p[np^].weapon);
  993. p[np^].leftuse--;
  994. if(p[np^].leftuse<=)
  995. p[np^].weapon=;
  996. }
  997. }
  998. void block408(int np)
  999. {
  1000. pmap();
  1001. puts("╔╦╗\t----【正义之手】----");
  1002. puts("╠?╣~清除对方的所有护甲,并为自己恢复等量的血量。");
  1003. puts("╚╩╝");
  1004. wait();
  1005. p[np].hp=min(p[np].hp+p[np^].armor,maxhp);
  1006. p[np^].armor=;
  1007. }
  1008. void block409(int np)
  1009. {
  1010. pmap();
  1011. puts("╔╦╗\t----【光辉圣印】----");
  1012. puts("╠?╣~恢复 2 点血量,触发一次随机幸运方块效果。");
  1013. puts("╚╩╝");
  1014. wait();
  1015. p[np].hp=min(p[np].hp+,maxhp);
  1016. map[p[np].px][p[np].py]=R()%(tot+kittot)+;
  1017. activate(np,p[np].px,p[np].py);
  1018. }
  1019. void block410(int np)
  1020. {
  1021. pmap();
  1022. puts("╔╦╗\t----【光灵之力】----");
  1023. puts("╠?╣~为对方恢复 2 点血量,自己装备一把攻击力: 4 ,耐久: 4 的光灵剑。");
  1024. puts("╚╩╝");
  1025. wait();
  1026. p[np^].hp=min(p[np^].hp+,maxhp);
  1027. getweapon(np,,);
  1028. }
  1029. void activate(int np,int tx,int ty)
  1030. {
  1031. if(map[tx][ty]>)
  1032. {
  1033. pmap();
  1034. printf("P%d触发了幸运方块!\n",np+);
  1035. wait();
  1036. int tmp=map[tx][ty];
  1037. map[tx][ty]=;
  1038. if(tmp<=tot)
  1039. switch(tmp)
  1040. {
  1041. case :block1(np); break;
  1042. case :block2(np); break;
  1043. case :block3(np); break;
  1044. case :block4(np); break;
  1045. case :block5(np); break;
  1046. case :block6(np); break;
  1047. case :block7(np); break;
  1048. case :block8(np); break;
  1049. case :block9(np); break;
  1050. case :block10(np); break;
  1051. case :block11(np); break;
  1052. case :block12(np); break;
  1053. case :block13(np); break;
  1054. case :block14(np); break;
  1055. case :block15(np); break;
  1056. case :block16(np); break;
  1057. case :block17(np); break;
  1058. case :block18(np); break;
  1059. case :block19(np); break;
  1060. case :block20(np); break;
  1061. case :block21(np); break;
  1062. case :block22(np); break;
  1063. case :block23(np); break;
  1064. case :block24(np); break;
  1065. case :block25(np); break;
  1066. case :block26(np); break;
  1067. case :block27(np); break;
  1068. case :block28(np); break;
  1069. case :block29(np); break;
  1070. case :block30(np); break;
  1071. }
  1072. if(tmp>tot)
  1073. switch(tmp-tot+*p[np].kit)
  1074. {
  1075. case :block101(np); break;
  1076. case :block102(np); break;
  1077. case :block103(np); break;
  1078. case :block104(np); break;
  1079. case :block105(np); break;
  1080. case :block106(np); break;
  1081. case :block107(np); break;
  1082. case :block108(np); break;
  1083. case :block109(np); break;
  1084. case :block110(np); break;
  1085. case :block201(np); break;
  1086. case :block202(np); break;
  1087. case :block203(np); break;
  1088. case :block204(np); break;
  1089. case :block205(np); break;
  1090. case :block206(np); break;
  1091. case :block207(np); break;
  1092. case :block208(np); break;
  1093. case :block209(np); break;
  1094. case :block210(np); break;
  1095. case :block301(np); break;
  1096. case :block302(np); break;
  1097. case :block303(np); break;
  1098. case :block304(np); break;
  1099. case :block305(np); break;
  1100. case :block306(np); break;
  1101. case :block307(np); break;
  1102. case :block308(np); break;
  1103. case :block309(np); break;
  1104. case :block310(np); break;
  1105. case :block401(np); break;
  1106. case :block402(np); break;
  1107. case :block403(np); break;
  1108. case :block404(np); break;
  1109. case :block405(np); break;
  1110. case :block406(np); break;
  1111. case :block407(np); break;
  1112. case :block408(np); break;
  1113. case :block409(np); break;
  1114. case :block410(np); break;
  1115. }
  1116. }
  1117. }
  1118. int port(int np,int tx,int ty)
  1119. {
  1120. if(tx<||tx>n||ty<||ty>m||(tx==p[np^].px&&ty==p[np^].py))
  1121. return ;
  1122. p[np].px=tx,p[np].py=ty;
  1123. if(map[tx][ty]>)
  1124. {
  1125. activate(np,tx,ty);
  1126. }
  1127. return ;
  1128. }
  1129. int attack()
  1130. {
  1131. if(abs(p[].px-p[].px)+abs(p[].py-p[].py)>)
  1132. {
  1133. printf("\n不在攻击范围!\n");
  1134. wait();
  1135. return ;
  1136. }
  1137. if(p[turn].leftuse>)
  1138. {
  1139. if(damage(turn^,p[turn].weapon))
  1140. return ;
  1141. p[turn].leftuse--;
  1142. if(!p[turn].leftuse)
  1143. p[turn].weapon=;
  1144. }
  1145. else
  1146. if(damage(turn^,))
  1147. return ;
  1148. step--;
  1149. int tx=p[turn^].px,ty=p[turn^].py;
  1150. if(p[turn^].px<p[turn].px)
  1151. tx=p[turn^].px-;
  1152. if(p[turn^].px>p[turn].px)
  1153. tx=p[turn^].px+;
  1154. if(p[turn^].py<p[turn].py)
  1155. ty=p[turn^].py-;
  1156. if(p[turn^].py>p[turn].py)
  1157. ty=p[turn^].py+;
  1158. port(turn^,tx,ty);
  1159. return ;
  1160. }
  1161. void useskill(int np)
  1162. {
  1163. pmap();
  1164. printf("P%d使用了技能!\n",np+);
  1165. switch(p[np].kit)
  1166. {
  1167. case :
  1168. {
  1169. puts("【英勇前进】装备一把2/2的武器,剩余移动次数 +1 。");
  1170. wait();
  1171. getweapon(np,,);
  1172. if(np==turn)
  1173. step++;
  1174. break;
  1175. }
  1176. case :
  1177. {
  1178. puts("【远古智慧】触发一次随机幸运方块效果。");
  1179. wait();
  1180. map[p[np].px][p[np].py]=R()%(tot+kittot)+;
  1181. activate(np,p[np].px,p[np].py);
  1182. break;
  1183. }
  1184. case :
  1185. {
  1186. puts("【精准射击】对 11x11 内的敌人造成 2 点伤害。");
  1187. wait();
  1188. if(abs(p[].px-p[].px)<=&&abs(p[].py-p[].py)<=)
  1189. damage(np^,);
  1190. break;
  1191. }
  1192. case :
  1193. {
  1194. puts("【治愈之光】为自己恢复 2 点血量。");
  1195. wait();
  1196. p[np].hp=min(p[np].hp+,maxhp);
  1197. break;
  1198. }
  1199. }
  1200. }
  1201. int goturn()
  1202. {
  1203. pmap();
  1204. printf(">>P%d正在掷骰子中",turn+);
  1205. int i;
  1206. step=R()%+;
  1207. skilluse=;
  1208. cx=cy=;
  1209. char input,linput=;
  1210. for(i=;i<=;i++)
  1211. {
  1212. wait();
  1213. printf("。");
  1214. }
  1215. pmap();
  1216. printf("掷到了%d点!",step);
  1217. wait();
  1218. while(step>)
  1219. {
  1220. pmap();
  1221. printf("[方向键移动,a键攻击,s键使用技能,o键结束,g键认输]剩余次数(%d):",step);
  1222. input=_getch();
  1223. if(input=='a')
  1224. {
  1225. step-=attack();
  1226. if(p[].life<=||p[].life<=)
  1227. return ;
  1228. continue;
  1229. }
  1230. if(input=='o')
  1231. break;
  1232. if(input=='g')
  1233. {
  1234. p[turn].life=;
  1235. p[turn].hp=;
  1236. resplayer(turn);
  1237. return ;
  1238. }
  1239. if(input=='s')
  1240. {
  1241. if(step<)
  1242. {
  1243. puts("\n剩余移动次数不足(最少 2 点)!");
  1244. wait();
  1245. continue;
  1246. }
  1247. if(skilluse<=)
  1248. {
  1249. puts("\n你本回合只能使用一次技能!");
  1250. wait();
  1251. continue;
  1252. }
  1253. useskill(turn);
  1254. skilluse--;
  1255. step-=;
  1256. if(p[].life<=||p[].life<=)
  1257. return ;
  1258. }
  1259. if(input==-)
  1260. input=_getch();
  1261. if(input==linput)
  1262. {
  1263. step-=port(turn,cx,cy);
  1264. cx=cy=;
  1265. if(p[].life<=||p[].life<=)
  1266. return ;
  1267. }
  1268. linput=input;
  1269. if(input==)
  1270. cx=p[turn].px,cy=p[turn].py-;
  1271. if(input==)
  1272. cx=p[turn].px-,cy=p[turn].py;
  1273. if(input==)
  1274. cx=p[turn].px,cy=p[turn].py+;
  1275. if(input==)
  1276. cx=p[turn].px+,cy=p[turn].py;
  1277. }
  1278. return ;
  1279. }
  1280. int main()
  1281. {
  1282. SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_GREEN|FOREGROUND_INTENSITY/*|
  1283. BACKGROUND_GREEN|BACKGROUND_RED|BACKGROUND_BLUE|BACKGROUND_INTENSITY*/);
  1284. srand(time(NULL));
  1285. pmenu();
  1286. puts(">按任意键进入游戏<");
  1287. getch();
  1288. selectkit();
  1289. makemap();
  1290. setplayer();
  1291. while(goturn())
  1292. turn^=;
  1293. if(p[].life<=&&p[].life<=)
  1294. {
  1295. puts("平局!");
  1296. }
  1297. else if(p[].life<=)
  1298. {
  1299. puts("P2获胜!");
  1300. }
  1301. else
  1302. {
  1303. puts("P1获胜!");
  1304. }
  1305. puts("~~~~~~~~~~~~~~~~~~~~~");
  1306. puts("<<制作者:CQzhangyu>>");
  1307. puts("~~~~~~~~~~~~~~~~~~~~~");
  1308. wait();
  1309. return ;
  1310. }

//代码在这里

【CQgame】[幸运方块 v1.1.2] [Lucky_Block v1.1.2]的更多相关文章

  1. 【CQgame】[幸运方块 v1.1.3] [Lucky_Block v1.1.3]

    搬家首发!!! 其实从初一我就写过一些小型战斗的游戏,但是画面都太粗糙,代码也比较乱,也就是和两三个同学瞎玩,但自从观摩了PoPoQQQ大神的游戏,顿时产生了重新写一部游戏的冲动,于是各种上网查找各种 ...

  2. kubernetes实战(十六):k8s高可用集群平滑升级 v1.11.x 到v1.12.x

    1.基本概念 升级之后所有的containers会重启,因为hash值会变. 不可跨版本升级. 2.升级Master节点 当前版本 [root@k8s-master01 ~]# kubeadm ver ...

  3. Kubernetes v1.10----部署kubernetes-dashboard v1.83

    Kubernetes v1.10----部署kubernetes-dashboard v1.83 1.下载 kubernetes-dashboard  yaml文件 #因为文件中的image指定的是谷 ...

  4. 使用kubeadm平滑地升级kubenetes集群(v1.10.2到v1.10.3)

    写在前面 kubernetes是目前最炙手火热的容器管理.调度.编排平台,不仅拥有全面的生态系统,而且还开源.开放自治,谁贡献的多,谁的话语权就大,云提供商都有专门的工程师来从事kubernetes开 ...

  5. 【翻译】Kinect v1和Kinect v2的彻底比较

      本连载主要是比较Kinect for Windows的现行版(v1)和次世代型的开发者预览版(v2),以C++开发者为背景介绍进化的硬件和软件.本文主要是对传感的配置和运行条件进行彻底的比较.   ...

  6. 【开源】SpringBootNetty聊天室V1.2.0升级版本介绍

    前言 SpringBoot!微服务微架构的基础,Netty通信框架的元老级别框架,即之前的SpringBoot与Netty的实现聊天室的功能后已经过了不到一周的时间啦,今天我们更新了项目版本从V1.0 ...

  7. CentOS 7.4 安装 K8S v1.11.0 集群所遇到的问题

    0.引言 最近打算将现有项目的 Docker 部署到阿里云上面,但是之前是单机部署,现在阿里云上面有 3 台机器,所以想做一个 Docker 集群.之前考虑是用 Docker Swarm 来做这个事情 ...

  8. kubeadm安装kubernetes V1.11.1 集群

    之前测试了离线环境下使用二进制方法安装配置Kubernetes集群的方法,安装的过程中听说 kubeadm 安装配置集群更加方便,因此试着折腾了一下.安装过程中,也有一些坑,相对来说操作上要比二进制方 ...

  9. 使用kubeadm安装Kubernetes v1.10

    关于K8S: Kubernetes是Google开源的容器集群管理系统.它构建于docker技术之上,为容器化的应用提供资源调度.部署运行.服务发现.扩 容缩容等整一套功能,本质上可看作是基于容器技术 ...

随机推荐

  1. NFS配置(centos)

    一.简介    NFS(Network File System/网络文件系统):       1).设置Linux系统之间的文件共享(Linux与Windows中间文件共享采用SAMBA服务): 2) ...

  2. <hr>标签不止创建html水平线也可以画圆噢

    看到上面这张图,第一反应是用photoshop类似作图软件画出来的,但那是华丽丽的错觉.一个简单的<hr>标签就能完成漂亮的效果,而不仅仅是创建html水平线.想知道怎么实现吗?Let's ...

  3. 使用VS2010编译Qt 5.6.1过程记录

    由于Qt官方发布的Qt 5.6.1二进制安装包没有对应VS2010版本的,而我的电脑上只安装了VS2010,因此只能自己编译. 本文记录本人的编译安装过程,以及其中遇到的一些问题. 本文使用VS201 ...

  4. python random模块

    random.random() 返回[0,1)之间的浮点数 random.randrange(stop)  /  random.randrange(start,stop[,step]) 返回[0,st ...

  5. MongoDB 学习笔记一: 配置

    下载MongoDB 下载地址:https://www.mongodb.com/download-center?jmp=nav#community 这里是在windows平台下安装MongoDB, 下载 ...

  6. 【JavaScript】--重点解析之跨域请求

    JSON JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式. JSON是用字符串来表示Javascript对象,例如可以在django中发送一个JSON格式 ...

  7. Java后台发送邮件

    一.实现思路: 1.设置连接参数 2.设置邮件相关属性 3.发送邮件 二.相关需求: 1.导入jar包: 2.设置email.properties mail.smtp.host=smtp.163.co ...

  8. wpf 悬浮窗口的实现

    又到了写点东西的时候,因为有了新的收获,所以用随笔来记录下自己的成长.话不多说,正入主题. 最近又遇到一个新的需求,有一组控件,需要悬浮显示在面板的边缘上,刚开始的时候,是不显示的,点击后显示,然后再 ...

  9. WordPress一键部署网站

    每个人心里都有一个建站梦,所以今天作为我第一篇文章,就给大家圆了这场梦. 今天我来详细的一步一步带领大家利用WordPress程序来建立自己的小站以及解决直接域名访问(本地安装wordpress请阅读 ...

  10. php json_encode

    1.该函数只接受utf-8编码的字符串,其他编码的字符串会返回false 2.字符串中的斜线'/'会被自动转义成'\/',如果不想被转义,可用如下方式(适用于php5.4及以上) json_encod ...