Pages

▼

Wednesday, May 28, 2014

Animated Name Printer in C++ Programming

This program generates pattern of ‘*’ of given input string.It has also chessboard type background. It is animated and continuously changes colour.

  1. /*This Program Makes Pattern Of String You Enter.

  2.   Input must be string without numbers and capital letters.*/

  3.  

  4. /* Variable info

  5.   r = radius of curve in characters like B and O

  6.   bkp = horisontal position of cursor

  7.   hkp = vertical position of cursor

  8.   dly = time delay in miliseconds between to animation screens

  9.   name = input string

  10.   other are temporary variables

  11. */

  12.  

  13. #include

  14. #include

  15. #define r 5

  16. #include

  17. #include

  18.  

  19. void main()

  20. {

  21. 	clrscr();

  22. 	int i,bkp=0,hkp=1,x,y,k=30,dly,cc,j,m=0;

  23. 	char name[12],p;

  24. 	//textbackground(BLACK);

  25. 	cprintf("Enter Your name(only small chars eg. hello): ");

  26. 	scanf("%s",name);

  27. 	cprintf("Enter color change speed(eg. 30) : ");

  28. 	scanf("%d",&dly);

  29. 	gotoxy(40,1);

  30. 	cprintf("\tBhargav Patel");

  31. 	_setcursortype(_NOCURSOR);

  32. 	bkp:

  33. 	bkp=0;

  34. 	hkp=1;

  35. 	clrscr();

  36. 		//klp:

  37. 	for(cc=0;cc<24;cc++)

  38. 	{

  39. 		for(j=0;j<72;j++)

  40. 		{

  41. 			if(cc%8<4)

  42. 			{

  43. 				if(j%16<8)

  44. 				{

  45. 					textcolor(m);

  46. 				}

  47. 				else

  48. 				{

  49. 					textcolor(m+1);

  50. 				}

  51. 			}

  52. 			else

  53. 			{

  54. 				if(j%16>=8)

  55. 				{

  56.  

  57. 					textcolor(m);

  58. 				}

  59. 				else

  60. 				{

  61. 					textcolor(m+1);

  62. 				}

  63.  

  64. 			}

  65.  

  66. 			cprintf("%c",219);

  67.  

  68. 		}

  69. 		printf("\n");

  70. 	}

  71. 	m++;

  72. 	delay(500);

  73. 	//goto klp;

  74.  

  75.  

  76. 	for(i=0;name[i]!='\0';i++)

  77. 	{

  78. 		textcolor(k-(i%9));

  79. 		//cprintf("%c",name[i]);

  80.  

  81. 		switch(name[i])

  82. 		{

  83.  

  84. case 'a':

  85.  

  86. for(x=1;x<=8;x++)

  87. 	{

  88. 		y=x;

  89. 		delay(dly);

  90. 		gotoxy(bkp+(7+y),hkp+(x));

  91. 		cprintf("**");

  92. 		delay(dly);

  93. 		gotoxy(bkp+(9-x),hkp+(y));

  94. 		cprintf("**");

  95. 	}

  96. 	gotoxy(bkp+(6),hkp+(5));

  97. 	for(x=1;x<=7;x++)

  98. 	{

  99. 		delay(dly);

  100. 		cprintf("*");

  101. 	}

  102. bkp+=17;

  103. break;

  104.  

  105.  

  106. case 'b':

  107.  

  108. for(x=1;x<=4;x++)

  109. 	{

  110. 		y=2*sqrt((r*r)-(x*x));

  111. 		gotoxy(bkp+(y-3),hkp+(3+x));

  112. 		delay(dly);

  113. 		cprintf("***");

  114. 		gotoxy(bkp+(y-3),hkp+(5-x));

  115. 		delay(dly);

  116. 		cprintf("***");

  117. 		gotoxy(bkp+(y-3),hkp+(9+x));

  118. 		delay(dly);cprintf("***");

  119. 		gotoxy(bkp+(y-3),hkp+(11-x));

  120. 		delay(dly);cprintf("***");

  121. 	}

  122. 	for(x=1;x<=13;x++)

  123. 	{

  124. 		gotoxy(bkp+(1),hkp+(x));

  125. 		delay(dly);cprintf("**");

  126. 	}

  127. bkp+=9;

  128. break;

  129.  

  130.  

  131. case 'c':

  132.  

  133. 	for(x=1;x<=4;x++)

  134. 	{

  135. 		y=4*sqrt((r*r)-(x*x));

  136. 		gotoxy(bkp+(20-y),hkp+(4+x));

  137. 		delay(dly);cprintf("***");

  138. 		gotoxy(bkp+(20-y),hkp+(6-x));

  139. 		delay(dly);cprintf("***");

  140. 	}

  141. bkp+=11;

  142. break;

  143.  

  144.  

  145.  

  146. case 'd':

  147.  

  148.  

  149. 	for(x=1;x<=5;x++)

  150. 	{

  151. 		y=4*sqrt((100)-(x*x));

  152. 		gotoxy(bkp+(y-31),hkp+(4+x));

  153. 		delay(dly);cprintf("***");

  154. 		gotoxy(bkp+(y-31),hkp+(6-x));

  155. 		delay(dly);cprintf("***");

  156. 	}

  157. 	for(x=1;x<=9;x++)

  158. 	{

  159. 		gotoxy(bkp+(1),hkp+(x));

  160. 		delay(dly);cprintf("**");

  161. 	}

  162.  

  163. bkp+=11;

  164. break;

  165.  

  166.  

  167.  

  168.  

  169. case 'e':

  170.  

  171. 	for(x=1;x<=10;x++)

  172. 	{

  173. 		gotoxy(bkp+1,hkp+x);

  174. 		delay(dly);cprintf("**");

  175. 	}

  176. 	for(x=3;x<=7;x++)

  177. 	{

  178. 		gotoxy(bkp+x,hkp+1);

  179. 		delay(dly);cprintf("*");

  180. 		gotoxy(bkp+x,hkp+2);

  181. 		delay(dly);cprintf("*");

  182. 		gotoxy(bkp+x,hkp+5);

  183. 		delay(dly);cprintf("*");

  184. 		gotoxy(bkp+x,hkp+6);

  185. 		delay(dly);cprintf("*");

  186. 		gotoxy(bkp+x,hkp+9);

  187. 		delay(dly);cprintf("*");

  188. 		gotoxy(bkp+x,hkp+10);

  189. 		delay(dly);cprintf("*");

  190. 	}

  191. 	bkp+=8;

  192.  

  193. break;

  194.  

  195.  

  196.  

  197. case 'f':

  198.  

  199. 	for(x=1;x<=10;x++)

  200. 	{

  201. 		gotoxy(bkp+1,hkp+x);

  202. 		delay(dly);cprintf("**");

  203. 	}

  204. 	for(x=3;x<=7;x++)

  205. 	{

  206. 		gotoxy(bkp+x,hkp+1);

  207. 		delay(dly);cprintf("*");

  208. 		gotoxy(bkp+x,hkp+2);

  209. 		delay(dly);cprintf("*");

  210. 		gotoxy(bkp+x,hkp+5);

  211. 		delay(dly);cprintf("*");

  212. 		gotoxy(bkp+x,hkp+6);

  213. 		delay(dly);cprintf("*");

  214.  

  215. 	}

  216. bkp+=8;

  217. break;

  218.  

  219.  

  220.  

  221. case 'g':

  222.  

  223.  

  224. 	for(x=1;x<=5;x++)

  225. 	{

  226. 		y=3*sqrt((100)-(x*x));

  227. 		gotoxy(bkp+(30-y),hkp+(4+x));

  228. 		delay(dly);cprintf("***");

  229. 		gotoxy(bkp+(30-y),hkp+(6-x));

  230. 		delay(dly);cprintf("***");

  231. 		gotoxy(bkp+(y-19),hkp+(4+x));

  232. 		delay(dly);cprintf("***");

  233. 	}

  234. 	gotoxy(bkp+7,hkp+5);

  235. 	for(x=1;x<=7;x++)

  236. 	{

  237. 	delay(dly);cprintf("*");

  238. 	}

  239. bkp+=13;

  240. break;

  241.  

  242.  

  243. case 'h':

  244.  

  245. 	for(x=1;x<=10;x++)

  246. 	{

  247. 		gotoxy(bkp+1,hkp+x);

  248. 		delay(dly);cprintf("**");

  249. 		gotoxy(bkp+7,hkp+x);

  250. 		delay(dly);cprintf("**");

  251. 	}

  252. 	for(x=3;x<=7;x++)

  253. 	{

  254. 		gotoxy(bkp+x,hkp+5);

  255. 		delay(dly);cprintf("*");

  256. 		gotoxy(bkp+x,hkp+6);

  257. 		delay(dly);cprintf("*");

  258. 	}

  259. bkp+=9;

  260. break;

  261.  

  262.  

  263. case 'i':

  264.  

  265. 	for(x=1;x<=10;x++)

  266. 	{

  267. 		gotoxy(bkp+4,hkp+x);

  268. 		delay(dly);cprintf("**");

  269. 	}

  270. 	for(x=1;x<=8;x++)

  271. 	{

  272. 		gotoxy(bkp+x,hkp+1);

  273. 		delay(dly);cprintf("*");

  274. 		gotoxy(bkp+x,hkp+2);

  275. 		delay(dly);cprintf("*");

  276. 		gotoxy(bkp+x,hkp+9);

  277. 		delay(dly);cprintf("*");

  278. 		gotoxy(bkp+x,hkp+10);

  279. 		delay(dly);cprintf("*");

  280. 	}

  281. 	bkp+=9;

  282. 	break;

  283.  

  284.  

  285.  

  286. case 'j':

  287.  

  288.  

  289. for(x=1;x<=5;x++)

  290. 	{

  291. 		y=3*sqrt((100)-(x*x));

  292. 		gotoxy(bkp+(30-y),hkp+(6+x));

  293. 		delay(dly);cprintf("**");

  294. 		//gotoxy(bkp+(30-y),hkp+(6-x));

  295. 		//delay(dly);cprintf("***");

  296. 		gotoxy(bkp+(y-21),hkp+(6+x));

  297. 		delay(dly);cprintf("**");

  298. 	}

  299. 	for(x=1;x<=7;x++)

  300. 	{

  301. 		gotoxy(bkp+8,hkp+x);

  302. 		delay(dly);cprintf("**");

  303. 	}

  304. 	for(x=3;x<=13;x++)

  305. 	{

  306. 		gotoxy(bkp+x,hkp+1);

  307. 		delay(dly);cprintf("*");

  308. 		gotoxy(bkp+x,hkp+2);

  309. 		delay(dly);cprintf("*");

  310. 	}

  311. bkp+=14;

  312. break;

  313.  

  314.  

  315.  

  316. case 'k':

  317.  

  318.  

  319. 	for(x=1;x<=10;x++)

  320. 	{

  321. 		gotoxy(bkp+1,hkp+x);

  322. 		delay(dly);cprintf("**");

  323. 	}

  324. 	for(x=1;x<=6;x++)

  325. 	{

  326. 		y=x;

  327. 		gotoxy(bkp+(y),hkp+(x+4));

  328. 		delay(dly);cprintf("**");

  329. 		gotoxy(bkp+(8-x),hkp+(y));

  330. 		delay(dly);cprintf("**");

  331. 	}

  332.  

  333. bkp+=9;

  334. break;

  335.  

  336.  

  337. case 'l':

  338.  

  339.  

  340. 	for(x=1;x<=10;x++)

  341. 	{

  342. 		gotoxy(bkp+1,hkp+x);

  343. 		delay(dly);cprintf("**");

  344. 	}

  345. 	for(x=3;x<=7;x++)

  346. 	{

  347. 		gotoxy(bkp+x,hkp+9);

  348. 		delay(dly);cprintf("*");

  349. 		gotoxy(bkp+x,hkp+10);

  350. 		delay(dly);cprintf("*");

  351. 	}

  352.  

  353. bkp+=8;

  354. break;

  355.  

  356.  

  357.  

  358. case 'm':

  359.  

  360.  

  361. 	for(x=1;x<=10;x++)

  362. 	{

  363. 		gotoxy(bkp+1,hkp+x);

  364. 		delay(dly);cprintf("**");

  365. 		gotoxy(bkp+11,hkp+x);

  366. 		delay(dly);cprintf("**");

  367. 	}

  368. 	for(x=1;x<=6;x++)

  369. 	{

  370. 		y=x;

  371. 		gotoxy(bkp+(y),hkp+(x));

  372. 		delay(dly);cprintf("**");

  373. 		gotoxy(bkp+(12-x),hkp+(y));

  374. 		delay(dly);cprintf("**");

  375. 	}

  376.  

  377.  

  378. bkp+=13;

  379. break;

  380.  

  381.  

  382. case 'n':

  383.  

  384.  

  385. 	for(x=1;x<=10;x++)

  386. 	{

  387. 		gotoxy(bkp+1,hkp+x);

  388. 		delay(dly);cprintf("**");

  389. 		gotoxy(bkp+10,hkp+x);

  390. 		delay(dly);cprintf("**");

  391. 	}

  392. 	for(x=1;x<=10;x++)

  393. 	{

  394. 		y=x;

  395. 		gotoxy(bkp+(y),hkp+(x));

  396. 		delay(dly);cprintf("**");

  397. 	}

  398.  

  399. bkp+=13;

  400. break;

  401.  

  402.  

  403.  

  404. case 'o':

  405.  

  406.  

  407.  

  408. 	for(x=1;x<=5;x++)

  409. 	{

  410. 		y=2*sqrt((100)-(x*x));

  411. 		gotoxy(bkp+(20-y),hkp+(4+x));

  412. 		delay(dly);cprintf("***");

  413. 		gotoxy(bkp+(20-y),hkp+(6-x));

  414. 		delay(dly);cprintf("***");

  415. 		gotoxy(bkp+(y-11),hkp+(4+x));

  416. 		delay(dly);cprintf("***");

  417. 		gotoxy(bkp+(y-11),hkp+(6-x));

  418. 		delay(dly);cprintf("***");

  419. 	}

  420.  

  421. bkp+=10;

  422. break;

  423.  

  424.  

  425. case 'p':

  426.  

  427.  

  428. 	for(x=1;x<=4;x++)

  429. 	{

  430. 		y=2*sqrt((r*r)-(x*x));

  431. 		gotoxy(bkp+(y-3),hkp+(3+x));

  432. 		delay(dly);cprintf("***");

  433. 		gotoxy(bkp+(y-3),hkp+(5-x));

  434. 		delay(dly);cprintf("***");

  435. 	}

  436. 	for(x=1;x<=11;x++)

  437. 	{

  438. 		gotoxy(bkp+(1),hkp+(x));

  439. 		delay(dly);cprintf("**");

  440. 	}

  441. bkp+=8;

  442. break;

  443.  

  444.  

  445.  

  446. case 'q':

  447.  

  448.  

  449. 	for(x=1;x<=5;x++)

  450. 	{

  451. 		y=2*sqrt((100)-(x*x));

  452. 		gotoxy(bkp+(20-y),hkp+(4+x));

  453. 		delay(dly);cprintf("***");

  454. 		gotoxy(bkp+(20-y),hkp+(6-x));

  455. 		delay(dly);cprintf("***");

  456. 		gotoxy(bkp+(y-11),hkp+(4+x));

  457. 		delay(dly);cprintf("***");

  458. 		gotoxy(bkp+(y-11),hkp+(6-x));

  459. 		delay(dly);cprintf("***");

  460. 	}

  461. 	for(x=1;x<=5;x++)

  462. 	{

  463. 		y=x;

  464. 		gotoxy(bkp+(y+4),hkp+(x+5));

  465. 		delay(dly);cprintf("**");

  466. 	}

  467. bkp+=11;

  468. break;

  469.  

  470.  

  471.  

  472. case 'r':

  473.  

  474.  

  475. 	for(x=1;x<=4;x++)

  476. 	{

  477. 		y=2*sqrt((r*r)-(x*x));

  478. 		gotoxy(bkp+(y-3),hkp+(3+x));

  479. 		delay(dly);cprintf("***");

  480. 		gotoxy(bkp+(y-3),hkp+(5-x));

  481. 		delay(dly);cprintf("***");

  482. 	}

  483. 	for(x=1;x<=11;x++)

  484. 	{

  485. 		gotoxy(bkp+(1),hkp+(x));

  486. 		delay(dly);cprintf("**");

  487. 	}

  488. 	for(x=1;x<=5;x++)

  489. 	{

  490. 		y=x;

  491. 		gotoxy(bkp+(y+3),hkp+(x+6));

  492. 		delay(dly);cprintf("**");

  493. 	}

  494. bkp+=9;

  495. break;

  496.  

  497.  

  498.  

  499.  

  500. case 's':

  501.  

  502.  

  503. 	for(x=1;x<=4;x++)

  504. 	{

  505. 		y=3*sqrt((r*r)-(x*x));

  506. 		gotoxy(bkp+(y-7),hkp+(x+9));

  507. 		delay(dly);cprintf("**");

  508. 		gotoxy(bkp+(y-7),hkp+(10-x));

  509. 		delay(dly);cprintf("**");

  510. 		gotoxy(bkp+(15-y),hkp+(x+4));

  511. 		delay(dly);cprintf("**");

  512. 		gotoxy(bkp+(15-y),hkp+(5-x));

  513. 		delay(dly);cprintf("**");

  514. 	}

  515. bkp+=9;

  516. break;

  517.  

  518.  

  519. case 't':

  520.  

  521.  

  522. 	for(x=1;x<=10;x++)

  523. 	{

  524. 		gotoxy(bkp+4,hkp+x);

  525. 		delay(dly);cprintf("**");

  526. 	}

  527. 	for(x=1;x<=8;x++)

  528. 	{

  529. 		gotoxy(bkp+x,hkp+1);

  530. 		delay(dly);cprintf("*");

  531. 		gotoxy(bkp+x,hkp+2);

  532. 		delay(dly);cprintf("*");

  533. 	}

  534. bkp+=9;

  535. break;

  536.  

  537.  

  538. case 'u':

  539.  

  540. 	for(x=1;x<=5;x++)

  541. 	{

  542. 		y=3*sqrt((100)-(x*x));

  543. 		gotoxy(bkp+(30-y),hkp+(5+x));

  544. 		delay(dly);cprintf("**");

  545. 		//gotoxy(bkp+(30-y),hkp+(6-x));

  546. 		//delay(dly);cprintf("***");

  547. 		gotoxy(bkp+(y-20),hkp+(5+x));

  548. 		delay(dly);cprintf("**");

  549. 	}

  550. 	for(x=1;x<=5;x++)

  551. 	{

  552. 		gotoxy(bkp+1,hkp+x);

  553. 		delay(dly);cprintf("**");

  554. 		gotoxy(bkp+9,hkp+x);

  555. 		delay(dly);cprintf("**");

  556. 	}

  557. bkp+=11;

  558. break;

  559.  

  560.  

  561. case 'v':

  562.  

  563.  

  564. 	for(x=1;x<=3;x++)

  565. 	{

  566. 		gotoxy(bkp+1,hkp+x);

  567. 		delay(dly);cprintf("**");

  568. 		gotoxy(bkp+10,hkp+x);

  569. 		delay(dly);cprintf("**");

  570. 	}

  571. 	for(x=1;x<=4;x++)

  572. 	{

  573. 		y=x;

  574. 		gotoxy(bkp+(y+1),hkp+(x+3));

  575. 		delay(dly);cprintf("**");

  576. 		gotoxy(bkp+(10-x),hkp+(y+3));

  577. 		delay(dly);cprintf("**");

  578. 	}

  579. bkp+=12;

  580. break;

  581.  

  582.  

  583.  

  584. case 'w':

  585.  

  586.  

  587.  

  588. 	for(x=1;x<=3;x++)

  589. 	{

  590. 		gotoxy(bkp+1,hkp+x);

  591. 		delay(dly);cprintf("**");

  592. 		gotoxy(bkp+15,hkp+x);

  593. 		delay(dly);cprintf("**");

  594. 	}

  595. 	for(x=1;x<=4;x++)

  596. 	{

  597. 		y=x;

  598. 		gotoxy(bkp+(y),hkp+(x+2));

  599. 		delay(dly);cprintf("**");

  600. 		gotoxy(bkp+(9-x),hkp+(y+2));

  601. 		delay(dly);cprintf("**");

  602. 	}

  603. 	for(x=1;x<=4;x++)

  604. 	{

  605. 		y=x;

  606. 		gotoxy(bkp+(y+6),hkp+(x+2));

  607. 		delay(dly);cprintf("**");

  608. 		gotoxy(bkp+(16-x),hkp+(y+2));

  609. 		delay(dly);cprintf("**");

  610. 	}

  611. bkp+=17;

  612. break;

  613.  

  614.  

  615. case 'x':

  616.  

  617.  

  618. 	for(x=1;x<=8;x++)

  619. 	{

  620. 		y=x;

  621. 		gotoxy(bkp+(y),hkp+(x));

  622. 		delay(dly);cprintf("**");

  623. 		gotoxy(bkp+(9-x),hkp+(y));

  624. 		delay(dly);cprintf("**");

  625. 	}

  626. bkp+=10;

  627. break;

  628.  

  629.  

  630. case 'y':

  631.  

  632.  

  633. 	for(x=1;x<=4;x++)

  634. 	{

  635. 		y=x;

  636. 		gotoxy(bkp+(y),hkp+(x));

  637. 		delay(dly);cprintf("**");

  638. 		gotoxy(bkp+(8-x),hkp+(y));

  639. 		delay(dly);cprintf("**");

  640. 	}

  641. 	for(x=3;x<=6;x++)

  642. 	{

  643. 		gotoxy(bkp+4,hkp+x);

  644. 		delay(dly);cprintf("**");

  645. 	}

  646. bkp+=8;

  647. break;

  648.  

  649.  

  650. case 'z':

  651.  

  652. 	for(x=1;x<=8;x++)

  653. 	{

  654. 		y=x;

  655. 		gotoxy(bkp+(9-x),hkp+(y));

  656. 		delay(dly);cprintf("**");

  657. 	}

  658. 	for(x=1;x<=8;x++)

  659. 	{

  660. 		gotoxy(bkp+x,hkp+1);

  661. 		delay(dly);cprintf("*");

  662. 		gotoxy(bkp+x,hkp+2);

  663. 		delay(dly);cprintf("*");

  664. 		gotoxy(bkp+(x),hkp+8);

  665. 		delay(dly);cprintf("*");

  666. 		gotoxy(bkp+(x),hkp+9);

  667. 		delay(dly);cprintf("*");

  668. 	}

  669. bkp+=10;

  670. break;

  671.  

  672.  

  673.  

  674. default:

  675. delay(dly);cprintf("Error in Input Or String is large to fit in Screen. Try Again");

  676. break;

  677. }

  678. bkp++;

  679.  

  680. if(bkp>=70)

  681. {

  682. bkp=0;

  683. hkp+=11;

  684. }

  685.  

  686. }

  687. k++;

  688. delay(1500);

  689. goto bkp;

  690. }



at

No comments:

Post a Comment