五个下午的时间!!!!终于过了!!
有史以来做的最复杂的一个题
这是我迄今为止做的最复杂也最具有挑战的一个oj作业。虽然之前做过比这个规模一些作业项目,但是往往有简单的模块框架,模块之前的关系也只是有些简单的联系,代码量虽然多,但是并不复杂。然而,然而这个题不仅有着复杂的逻辑关系,而且是oj测试啊!!意味着你需要实现所有特性,而且不能有一丁点的错误!
从决定开始做这个题,到最后两个平台AC,前前后后大概花了5个下午的时间。
在读完题后(相信我,为了搞懂每一个细节,题目我读了整整一个小时),coding前,大概花了两个到三个小时,画图、构思程序应该有着什么样的结构,都应该有哪些类,类之前的关系是什么样的,类中应该有哪些元素。。。。等等
不过即使想了这么长时间,coding途中也遇到不少问题导致最后的代码封装性差、结构也不是那么美好。。
coding时很多地方抽象得并不合理,为了少量修改目前已经完成的代码(不想去动大结构)而作出妥协。结果越到后面越发现整个程序非常混乱,各个类耦合度过高,程序的健壮性十分差。常常是为了一个新功能的实现,要引起三四五六处修改,一不注意就会留下bug。最终调试bug的时候,对于前期没构思好结构的后加的代码修改起来相当麻烦。
虽然我一直在注重代码的重用性,但是到最后我还是感觉代码的重用性不高,程序的结构还能优化的更好
做完了这个作业,让我感觉我就好像是重新学习了c艹,c艹的继承和多态、虚函数等一些特性,从认识到了解终于可以做到了熟悉掌握。
我要是有精力,一定要重构一下= =。。。
从一开始就认认真真的画类图,把游戏角色类(建筑、武士、武器)和游戏逻辑类、单元测试类的各自特征和功能梳理得更有条理,把整条游戏流程通过写伪代码的方式弄个清晰明了后再开始coding。。
总之,编码前的准备是否足够充分决定了你编码时和debug时的痛苦程度啊

错误

我认为魔兽世界终结版这题有错误!!

一开始我在poj上提交通过了,然后再从coursera上提交居然WA

我结合讨论区花雨同学的留言再测试了下数据。

poj上提供的27组测试数据中,在case 16:

006:00 blue dragon 7 born

Its morale is 11.62

我的输出数据(编译器vs2015)是:

006:00 blue dragon 7 born

Its morale is 11.63

经调试,我发现真正的正确答案应该就是11.63。

有人反映是编译器的问题,我测试了gcc的输出结果,同样是11.63

注意!即使我的输出结果和poj提供的out.txt文件不同,我的代码仍然是Accept!只是在coursera上WA。

然后,我修改了我的代码,不再进行四舍五入了,改为直接截尾保留两位小数。

这时,我的输出与out.txt相同了,在poj提交仍然Accept!

在coursera上提交也通过了!!

所以,我认为,有两个问题:

1.poj的评测有问题(不然我两次不同的代码输出不同的结果都能AC啊)

2.两个平台的测试数据都有问题(按照题目描述的四舍五入应该是11.63才对)

希望助教和老师能再审查一下题目啊,毕竟愿意做这个题的人不多,花出很大心血做完后却一直不能通过得多痛心啊!

AC代码:

本代码在vs上能编译,若想提交到oj上,需要改动一些地方

  1. // World of Warcraft.cpp : 定义控制台应用程序的入口点。
  2. //
  3.  
  4. #include "stdafx.h"
  5.  
  6. #include <cstdio>
  7. #include <string>
  8. #include <cstdlib>
  9. #include <cstring>
  10. #include <iostream>
  11. #include <vector>
  12. #include <map>
  13. #include <queue>
  14.  
  15. using namespace std;
  16. #define _CRT_SECURE_NO_WARNINGS
  17. int M, N, R, K, T;//基础数据
  18. int SoldierBlood[];
  19. int SoldierAd[];
  20. int CurrentTime;
  21.  
  22. string toString(int t)
  23. {
  24. char buf[];
  25. sprintf_s(buf, "%d", t);
  26. string b = buf;
  27. return b;
  28. }
  29. string printNowTime()
  30. {
  31. int t = CurrentTime;
  32. int h = t / ;
  33. int m = t % ;
  34. string s;
  35. s += h / + '';
  36. s += (h / ) % + '';
  37. s += h % + '';
  38. s += ':';
  39. s += m / + '';
  40. s += m % + '';
  41. return s + ' ';
  42. }
  43.  
  44. class Weapon
  45. {
  46. protected:
  47. int Attack;
  48. int Belong;//存放的soldier的uid
  49. public:
  50. int getAttack()
  51. {
  52. return Attack;
  53. }
  54. void setBelong(int t)
  55. {
  56. Belong = t;
  57. }
  58. virtual void init() = ;
  59. virtual int lose() = ;//返回0的时候表示失去该武器
  60. virtual int getType() = ;//0 sword 1 bomb 2 arrow
  61. virtual string getPrint() = ;
  62. virtual ~Weapon() {};
  63. };
  64. class Sword:public Weapon
  65. {
  66. public:
  67. void init();
  68. int lose()
  69. {
  70. Attack *= 0.8;
  71. return Attack;
  72. }
  73. int getType()
  74. {
  75. return ;
  76. }
  77. void setAttack(int t)
  78. {
  79. Attack = t*0.2;
  80. }
  81. string getPrint()
  82. {
  83. return "sword(" + toString(Attack) + ')';
  84. }
  85. };
  86. class Arrow :public Weapon
  87. {
  88. private:
  89.  
  90. public:
  91. int time;
  92. void init()
  93. {
  94. Attack = ;
  95. time = ;
  96. }
  97. int lose()
  98. {
  99. time--;
  100. return time;
  101. }
  102. int getType()
  103. {
  104. return ;
  105. }
  106. string getPrint()
  107. {
  108. return "arrow(" + toString(time) + ')';
  109. }
  110. };
  111. class Bomb :public Weapon
  112. {
  113. public:
  114. void init()
  115. {
  116. Attack = ;
  117. }
  118. int lose()//只能用一次,只要调用了就没了
  119. {
  120. return ;
  121. }
  122. int getType()
  123. {
  124. return ;
  125. }
  126. string getPrint()
  127. {
  128. return "bomb";
  129. }
  130. };
  131.  
  132. class Soldier
  133. {
  134. protected:
  135.  
  136. int Attack;
  137. int Id;
  138. int uId;
  139. int Camp;//0:red,1:blue;
  140.  
  141. public:
  142. int Blood;//<=0即为死亡
  143. int BloodWin;//
  144. int isLive;//0 die 1 live -1 runaway
  145. int tArrow;//实现同时射箭的处理。先记录下中箭的数值,在战争开始时再结算中箭的伤害。
  146. Arrow* hasArrow;//没有即为NULL
  147. Bomb* hasBomb;//
  148. int dieByArrow;
  149. string getCampName()
  150. {
  151. if (Camp == ) return "red";
  152. return "blue";
  153. }
  154. string getPrint()//return like this "red lion 2"
  155. {
  156. string s;
  157. s += getCampName() + ' ' + getName() + ' ' +toString(Id);
  158. return s;
  159. }
  160. Soldier()
  161. {
  162. isLive = ;
  163. hasArrow = NULL;
  164. hasBomb = NULL;
  165. tArrow = ;
  166. BloodWin = ;
  167. dieByArrow = ;
  168. }
  169. void attackByArrow(int t)
  170. {
  171. tArrow += t;
  172. }
  173. void loseByArrow()
  174. {
  175. loseBlood(tArrow);
  176. tArrow = ;
  177. }
  178. void loseBlood(int t)//降低生命值
  179. {
  180. Blood -= t;
  181. if (Blood <= )
  182. {
  183. isLive = ;
  184. //Todo
  185. die();
  186. }
  187. }
  188. int getBlood()
  189. {
  190. return Blood;
  191. }
  192. int getAttack()
  193. {
  194. return Attack;
  195. }
  196. void setId(int t)
  197. {
  198. Id = t;
  199. }
  200. int getId()
  201. {
  202. return Id;
  203. }
  204. void setuId(int t)
  205. {
  206. uId = t;
  207. }
  208. int getuId()
  209. {
  210. return uId;
  211. }
  212. void setCamp(int t)
  213. {
  214. Camp = t;
  215. }
  216. int getCamp()
  217. {
  218. return Camp;
  219. }
  220. virtual void init() = ;//武士初始化,推迟到子类中实现
  221. virtual int fight() = ;//返回攻击的攻击力
  222. virtual int fightback() = ;//返回反击的攻击力
  223. virtual int getType() = ;//返回该武士的类型编号,0: dragon 、1:ninja、2:iceman、3:lion、4:wolf
  224. virtual string getName() = ;//返回该武士的类型
  225. virtual void die() = ;//死亡
  226. virtual void winFight(Soldier* p,int t) = ;//获胜
  227. virtual void loseFight(Soldier* p,int t) = ;//输掉
  228. virtual void drawFight(Soldier* p,int t) = ;//平局
  229. virtual void loseWeapon(int t) = ;
  230. virtual void printWeapon() = ;
  231. virtual ~Soldier() {}//虚函数析构
  232. };
  233.  
  234. int getSwordAttack(Weapon* p)//fight时处理sword的事件,返回sword的攻击力
  235. {
  236. if (!p) return ;
  237. if (p->getType() != ) return ;//not sword,return 0
  238. int t = p->getAttack();
  239. //p->lose();//sword 变钝 // 对打时处理吧
  240. //if (p->getAttack() == 0)
  241. //{
  242. // delete p;
  243. // p = NULL;
  244. //}
  245. return t;
  246. }
  247. void getWeapon(Soldier * t,Weapon* &p, int code);//获得武器
  248.  
  249. class Dragon :public Soldier
  250. {
  251. private:
  252.  
  253. public:
  254. double Morale;
  255. Weapon* mWeapon;//NULL代表没有武器
  256. Dragon()
  257. {
  258. Blood = SoldierBlood[];
  259. Attack = SoldierAd[];
  260. mWeapon = NULL;
  261. }
  262. double getMorale()
  263. {
  264. return Morale;
  265. }
  266. int getWeaponType()//-1 no weapon,0 sword
  267. {
  268. if (mWeapon == NULL) return -;
  269. return mWeapon->getType();
  270. }
  271. void init();
  272.  
  273. void die()
  274. {
  275. //if (mWeapon != NULL) delete mWeapon;
  276. isLive = ;
  277. Blood = ;
  278. }
  279. int getType()
  280. {
  281. return ;
  282. }
  283. string getName()
  284. {
  285. return "dragon";
  286. }
  287. void yell(int t);//judge whether to yell
  288.  
  289. void winFight(Soldier* p,int t)
  290. {
  291. BloodWin += ;
  292. Morale += 0.2;
  293. yell(t);
  294. }
  295.  
  296. void loseFight(Soldier * p,int t)
  297. {
  298.  
  299. }
  300. void drawFight(Soldier * p,int t)
  301. {
  302. Morale -= 0.2;
  303. yell(t);
  304. }
  305. int fight()
  306. {
  307. int ad = Attack;
  308. ad += getSwordAttack(mWeapon);
  309. return ad;
  310. }
  311. int fightback()
  312. {
  313. int ad = Attack / ;
  314. ad += getSwordAttack(mWeapon);
  315. return ad;
  316. }
  317. void loseWeapon(int t)//战斗后调用
  318. {
  319. if (mWeapon&&mWeapon->getType()==t)
  320. {
  321. if (mWeapon->lose() == )
  322. {
  323. //delete mWeapon;
  324. mWeapon = NULL;
  325. }
  326. }
  327. }
  328. void printWeapon()
  329. {
  330. string s = printNowTime() + getPrint() + " has ";
  331. if (mWeapon == NULL)
  332. s += "no weapon";
  333. else
  334. s += mWeapon->getPrint();
  335. puts(s.c_str());
  336. }
  337. };
  338. class Ninja :public Soldier
  339. {
  340. private:
  341.  
  342. public:
  343. Weapon *mWeapon1, *mWeapon2;
  344. Ninja()
  345. {
  346. Blood = SoldierBlood[];
  347. Attack = SoldierAd[];
  348. mWeapon1 = NULL;
  349. mWeapon2 = NULL;
  350. }
  351. int getWeaponType1()
  352. {
  353. if (mWeapon1 == NULL) return -;
  354. return mWeapon1->getType();
  355. }
  356. int getWeaponType2()
  357. {
  358. if (mWeapon2 == NULL) return -;
  359. return mWeapon2->getType();
  360. }
  361. int getType()
  362. {
  363. return ;
  364. }
  365. string getName()
  366. {
  367. return "ninja";
  368. }
  369. void init()
  370. {
  371. getWeapon(this,mWeapon1, Id % );
  372. if (mWeapon1) mWeapon1->setBelong(getuId());//设置属于谁的
  373. getWeapon(this,mWeapon2, (Id+) % );
  374. if (mWeapon2) mWeapon2->setBelong(getuId());//设置属于谁的
  375. }
  376. void die()
  377. {
  378. //if (mWeapon1) delete mWeapon1;
  379. //if (mWeapon2) delete mWeapon2;
  380. isLive = ;
  381. }
  382. void winFight(Soldier *p, int t)
  383. {
  384. BloodWin += ;
  385. }
  386. void loseFight(Soldier *p, int t)
  387. {
  388.  
  389. }
  390. void drawFight(Soldier *p, int t)
  391. {
  392.  
  393. }
  394. int fight()
  395. {
  396. int ad = Attack;
  397. if(mWeapon1)ad += getSwordAttack(mWeapon1);
  398. if(mWeapon2)ad += getSwordAttack(mWeapon2);
  399. return ad;
  400. }
  401. void loseWeapon(int t)//战斗后调用
  402. {
  403. if (mWeapon1&&mWeapon1->getType()==t)
  404. {
  405. if (mWeapon1->lose()==)
  406. {
  407. //delete mWeapon1;
  408. mWeapon1 = NULL;
  409. }
  410. }
  411. if (mWeapon2&&mWeapon2->getType() == t)
  412. {
  413. if (mWeapon2->lose()==)
  414. {
  415. //delete mWeapon2;
  416. mWeapon2 = NULL;
  417. }
  418. }
  419. }
  420. int fightback()//不反击,所以认为是0
  421. {
  422. return ;
  423. }
  424. void printWeapon()
  425. {
  426. string s = printNowTime() + getPrint() + " has ";
  427. if (mWeapon1 == NULL && mWeapon2 == NULL)
  428. s += "no weapon";
  429. else if (mWeapon1 == NULL)
  430. {
  431. s += mWeapon2->getPrint();
  432. }
  433. else if (mWeapon2 == NULL)
  434. {
  435. s += mWeapon1->getPrint();
  436. }
  437. else
  438. {
  439. if (mWeapon1->getType() == )
  440. s += mWeapon1->getPrint();
  441. if (mWeapon2->getType() == )
  442. s += mWeapon2->getPrint();
  443. if (mWeapon1->getType() == )
  444. {
  445. if (s[s.size() - ] != ' ') s += ',';
  446. s += mWeapon1->getPrint();
  447. }
  448. if (mWeapon2->getType() == )
  449. {
  450. if (s[s.size() - ] != ' ') s += ',';
  451. s += mWeapon2->getPrint();
  452. }
  453. if (mWeapon1->getType() == )
  454. {
  455. if (s[s.size() - ] != ' ') s += ',';
  456. s += mWeapon1->getPrint();
  457. }
  458. if (mWeapon2->getType() == )
  459. {
  460. if (s[s.size() - ] != ' ') s += ',';
  461. s += mWeapon2->getPrint();
  462. }
  463. }
  464. puts(s.c_str());
  465. }
  466. };
  467.  
  468. class Iceman :public Soldier
  469. {
  470. private:
  471.  
  472. public:
  473. Weapon *mWeapon;
  474. int Step;
  475. Iceman()
  476. {
  477. Blood = SoldierBlood[];
  478. Attack = SoldierAd[];
  479. mWeapon = NULL;
  480. Step = ;
  481. }
  482. int getWeaponType()
  483. {
  484. if (mWeapon == NULL) return -;
  485. return mWeapon->getType();
  486. }
  487. int getType()
  488. {
  489. return ;
  490. }
  491. string getName()
  492. {
  493. return "iceman";
  494. }
  495. void init()
  496. {
  497. getWeapon(this,mWeapon, Id % );
  498. if (mWeapon) mWeapon->setBelong(getuId());//设置属于谁的
  499. }
  500. void die()
  501. {
  502. //if (mWeapon) delete mWeapon;
  503. isLive = ;
  504. }
  505. void winFight(Soldier *p, int t)
  506. {
  507. BloodWin += ;
  508. }
  509. void loseFight(Soldier *p, int t)
  510. {
  511.  
  512. }
  513. void drawFight(Soldier *p, int t)
  514. {
  515.  
  516. }
  517. void loseWeapon(int t)//战斗后调用
  518. {
  519. if (mWeapon&&mWeapon->getType() == t)
  520. {
  521. if (mWeapon->lose()== )
  522. {
  523. //delete mWeapon;
  524. mWeapon = NULL;
  525. }
  526. }
  527. }
  528. void Move()
  529. {
  530. Step++;
  531. if (Step == )
  532. {
  533. Step = ;
  534. Blood -= ;
  535. Attack += ;
  536. if (Blood <= ) Blood = ;
  537. }
  538. }
  539. int fight()
  540. {
  541. int ad = Attack;
  542. ad += getSwordAttack(mWeapon);
  543. return ad;
  544. }
  545. int fightback()
  546. {
  547. int ad = Attack / ;
  548. ad += getSwordAttack(mWeapon);
  549. return ad;
  550. }
  551. void printWeapon()
  552. {
  553. string s = printNowTime() + getPrint() + " has ";
  554. if (mWeapon == NULL)
  555. s += "no weapon";
  556. else
  557. s += mWeapon->getPrint();
  558. puts(s.c_str());
  559. }
  560. };
  561. class Lion :public Soldier
  562. {
  563. private:
  564. int Loyalty;
  565. int tBlood;//要转移的Blood
  566. public:
  567. Lion()
  568. {
  569. Blood = SoldierBlood[];
  570. Attack = SoldierAd[];
  571. }
  572. void moveBlood()
  573. {
  574. tBlood = Blood-tArrow;
  575. }
  576. void init();
  577. void die()
  578. {
  579. isLive = ;
  580. }
  581. int getLoyalty()
  582. {
  583. return Loyalty;
  584. }
  585. void loseLoyalty()
  586. {
  587. Loyalty -= K;
  588. }
  589. int fight()
  590. {
  591. return Attack;
  592. }
  593. int fightback()
  594. {
  595. return Attack / ;
  596. }
  597. void winFight(Soldier *p, int t)
  598. {
  599. BloodWin += ;
  600. }
  601. void loseFight(Soldier *p, int t)
  602. {
  603. if(dieByArrow==)p->Blood += tBlood;
  604. }
  605. void drawFight(Soldier *p, int t)
  606. {
  607. loseLoyalty();
  608. }
  609. void loseWeapon(int t)
  610. {
  611.  
  612. }
  613. int getType()
  614. {
  615. return ;
  616. }
  617. string getName()
  618. {
  619. return "lion";
  620. }
  621. void runAway()
  622. {
  623. Blood = ;
  624. isLive = ;//暂时先设置为0吧,逃跑了就当他死了
  625. }
  626. void printWeapon()
  627. {
  628. string s = printNowTime() + getPrint() + " has ";
  629. s += "no weapon";
  630. puts(s.c_str());
  631. }
  632. };
  633. class Wolf :public Soldier
  634. {
  635. private:
  636.  
  637. public:
  638. //Weapon* mWeapon;
  639. Weapon* swordWeapon;
  640. Arrow* arrowWeapon;
  641. Bomb* bombWeapon;
  642. Wolf()
  643. {
  644. Blood = SoldierBlood[];
  645. Attack = SoldierAd[];
  646. }
  647. /*int getWeaponType()
  648. {
  649. return WeaponType;
  650. }*/
  651. void init()
  652. {
  653. swordWeapon = NULL;
  654. arrowWeapon = NULL;
  655. bombWeapon = NULL;
  656. }
  657. void die()
  658. {
  659. //if (swordWeapon) delete swordWeapon;
  660. //if ()
  661. isLive = ;
  662. }
  663. void winFight(Soldier *p, int t)
  664. {
  665. switch (p->getType())
  666. {
  667. case :
  668. {
  669. takeWeapon(((Dragon *)p)->mWeapon);
  670. break;
  671. }
  672. case :
  673. {
  674. takeWeapon(((Ninja *)p)->mWeapon1);
  675. takeWeapon(((Ninja *)p)->mWeapon2);
  676. break;
  677. }
  678. case :
  679. {
  680. takeWeapon(((Iceman *)p)->mWeapon);
  681. break;
  682. }
  683. case :
  684. {
  685. takeWeapon(((Wolf *)p)->swordWeapon);
  686. takeWeapon(((Wolf *)p)->bombWeapon);
  687. takeWeapon(((Wolf *)p)->arrowWeapon);
  688. break;
  689. }
  690. }
  691. BloodWin += ;
  692. }
  693. void loseFight(Soldier *p, int t)
  694. {
  695.  
  696. }
  697. void drawFight(Soldier *p, int t)
  698. {
  699.  
  700. }
  701. void takeWeapon(Weapon *p)//缴获武器
  702. {
  703. if (p == NULL) return;
  704. if (p->getType() == &&swordWeapon==NULL)
  705. {
  706. swordWeapon = p;
  707. }
  708. if (p->getType() == && bombWeapon == NULL)
  709. {
  710. bombWeapon =(Bomb *) p;
  711. hasBomb = (Bomb *)p;
  712. }
  713. if (p->getType() == && arrowWeapon == NULL)
  714. {
  715. arrowWeapon = (Arrow *)p;
  716. hasArrow = (Arrow *)p;
  717. }
  718. }
  719. int fight()
  720. {
  721. int ad = Attack;
  722. ad += getSwordAttack(swordWeapon);
  723. return ad;
  724. }
  725. int fightback()
  726. {
  727. int ad = Attack / ;
  728. ad += getSwordAttack(swordWeapon);
  729. return ad;
  730. }
  731. void loseWeapon(int t)//战斗后调用
  732. {
  733. if (swordWeapon&&t==)
  734. {
  735. if (swordWeapon->lose() == )
  736. {
  737. //delete swordWeapon;
  738. swordWeapon = NULL;
  739. }
  740. }
  741. if (bombWeapon&&t == )
  742. {
  743. if (bombWeapon->lose() == )
  744. {
  745. //delete bombWeapon;
  746. bombWeapon = NULL;
  747. }
  748. }
  749. if (arrowWeapon&&t == )
  750. {
  751. if (arrowWeapon->lose() == )
  752. {
  753. //delete arrowWeapon;
  754. arrowWeapon = NULL;
  755. }
  756. }
  757. }
  758. int getType()
  759. {
  760. return ;
  761. }
  762. string getName()
  763. {
  764. return "wolf";
  765. }
  766. void printWeapon()
  767. {
  768. string s = printNowTime() + getPrint() + " has ";
  769. if (swordWeapon == NULL && bombWeapon == NULL && arrowWeapon ==NULL)
  770. s += "no weapon";
  771. else
  772. {
  773. if (arrowWeapon != NULL) s += arrowWeapon->getPrint();
  774. if (bombWeapon != NULL)
  775. {
  776. if (s[s.size() - ] != ' ') s += ',';
  777. s += bombWeapon->getPrint();
  778. }
  779. if (swordWeapon != NULL)
  780. {
  781. if (s[s.size() - ] != ' ') s += ',';
  782. s += swordWeapon->getPrint();
  783. }
  784. }
  785. puts(s.c_str());
  786. }
  787. };
  788. vector<Soldier *> mAllSoldier;//全部武士集合
  789.  
  790. class Base
  791. {
  792. public:
  793. int Blood;
  794. int BloodWin;
  795. int SoidierNum;//从1开始编号
  796. vector<Soldier*> mSoldier;//武士集合
  797. int occupied;//0 no,1
  798. void init()//初始化大本营
  799. {
  800. Blood = M;
  801. SoidierNum = ;
  802. /*for (int i = 0; i <= mSoldier.size(); i++)
  803. {
  804. delete mSoldier[i];
  805. }*/
  806. mSoldier.clear();
  807. //mSoldier.push_back(NULL);
  808. occupied = ;
  809. }
  810. void tackBloodWin()
  811. {
  812. Blood += BloodWin;
  813. BloodWin = ;
  814. }
  815. virtual int creatwho(int t) = ;
  816. virtual int getCamp() = ;
  817. virtual string getCampName() = ;
  818. Soldier* CreatSoldier();//返回指向soldier的指针,创建失败的时候的返回null
  819. };
  820.  
  821. class RedBase :public Base
  822. {
  823. public:
  824. int creatwho(int t)
  825. {
  826. return t % ;
  827. }
  828. int getCamp()
  829. {
  830. return ;
  831. }
  832. string getCampName()
  833. {
  834. return "red";
  835. }
  836. };
  837. RedBase *RedBaseInstance;//红魔军实例
  838. class BlueBase:public Base
  839. {
  840. public:
  841. int creatwho(int t)
  842. {
  843. int k = t % ;
  844. switch (k)
  845. {
  846. case :
  847. return ;
  848. case :
  849. return ;
  850. case :
  851. return ;
  852. case :
  853. return ;
  854. case :
  855. return ;
  856. }
  857. }
  858. int getCamp()
  859. {
  860. return ;
  861. }
  862. string getCampName()
  863. {
  864. return "blue";
  865. }
  866. };
  867. BlueBase *BlueBaseInstance;//蓝魔军实例
  868. class City
  869. {
  870. private:
  871.  
  872. public:
  873. int Id;
  874. Soldier* RedSoldier;
  875. Soldier* BlueSoldier;
  876. int Blood;
  877. int whoLastWin;//0 no 1 red 2 blue
  878. int Flag;//as up
  879. int FlagRaise;
  880. int lastPrintFlag;
  881. int whoFirst;//who first to attack,0 red,1 blue
  882. int redReward, blueReward;
  883. queue<string> output;
  884. City(int t)
  885. {
  886. lastPrintFlag = ;
  887. Id = t;
  888. Blood = ;
  889. whoLastWin = ;
  890. Flag = ;
  891. redReward = ;
  892. blueReward = ;
  893. FlagRaise = ;
  894. RedSoldier = NULL;
  895. BlueSoldier = NULL;
  896. while (!output.empty()) output.pop();
  897. }
  898. void addBlood()
  899. {
  900. Blood += ;
  901. }
  902. int takeBlood(int who)//拿走所有的生命元
  903. {
  904. int t = Blood;
  905. Blood = ;
  906. string s = printNowTime();
  907. if (who == )
  908. {
  909. s += RedSoldier->getPrint();
  910. }
  911. if (who == )
  912. {
  913. s += BlueSoldier->getPrint();
  914. }
  915. s += " earned " +toString(t)+ " elements for his headquarter";
  916. puts(s.c_str());
  917. return t;
  918. }
  919. int takeWinBlood(int c, int who)
  920. {
  921. int t = Blood;
  922. Blood = ;
  923. string s = printNowTime();
  924. if (who == )
  925. {
  926. s += RedSoldier->getPrint();
  927. }
  928. if (who == )
  929. {
  930. s += BlueSoldier->getPrint();
  931. }
  932. s += " earned " + toString(t) + " elements for his headquarter";
  933. //puts(s.c_str());
  934. output.push(s);
  935. return t;
  936. }
  937. void printFlag(int p)
  938. {
  939. string s=printNowTime();
  940. if (Flag == )
  941. {
  942. s += "red flag raised in city " + toString(p);
  943. }
  944. else
  945. {
  946. s += "blue flag raised in city " + toString(p);
  947. }
  948. puts(s.c_str());
  949. }
  950. void changeFlag(int p,int t)//t 1 red win ,t 2 blue win
  951. {
  952. //if (Flag == t) return;
  953. if (t == )
  954. {
  955. if (whoLastWin == )
  956. {
  957. Flag = ;
  958. FlagRaise = ;
  959. //printFlag(p);
  960. whoFirst = ;
  961. }
  962. else
  963. {
  964. whoLastWin = ;
  965. }
  966. }
  967. else
  968. {
  969. if (whoLastWin == )
  970. {
  971. Flag = ;
  972. FlagRaise = ;
  973. //printFlag(p);
  974. whoFirst = ;
  975. }
  976. else
  977. {
  978. whoLastWin = ;
  979. }
  980. }
  981. }
  982.  
  983. };
  984. vector <City*> mAllCity;
  985.  
  986. void Init()//游戏初始化
  987. {
  988. cin >> M >> N >> R >> K >> T;
  989. cin >> SoldierBlood[] >> SoldierBlood[] >> SoldierBlood[] >> SoldierBlood[] >> SoldierBlood[];
  990. cin >> SoldierAd[] >> SoldierAd[] >> SoldierAd[] >> SoldierAd[] >> SoldierAd[];
  991.  
  992. N++;//使得编号N为bluebase
  993.  
  994. for (int i = ; i < mAllSoldier.size(); i++)
  995. {
  996. delete mAllSoldier[i];
  997. }
  998. mAllSoldier.clear();
  999. //mAllSoldier.push_back(NULL);//放入一个空指针占位
  1000.  
  1001. RedBaseInstance = new RedBase();
  1002. RedBaseInstance->init();
  1003. BlueBaseInstance = new BlueBase();
  1004. BlueBaseInstance->init();
  1005.  
  1006. for (int i = ; i < mAllCity.size(); i++)
  1007. {
  1008. delete mAllCity[i];
  1009. }
  1010. mAllCity.clear();
  1011. for (int i = ; i <= N; i++)//0号city为redbase,N号为bluebase
  1012. {
  1013.  
  1014. mAllCity.push_back(new City(i));
  1015. mAllCity[i]->whoFirst = (i+) % ;
  1016. }
  1017. }
  1018.  
  1019. string printTime()
  1020. {
  1021. int t = CurrentTime;
  1022. int h = t / ;
  1023. int m = t % ;
  1024. string s;
  1025. s += h / + '';
  1026. s += (h / ) % + '';
  1027. s += h % + '';
  1028. s += ':';
  1029. s += m / + '';
  1030. s += m % + '';
  1031. return s;
  1032. }
  1033.  
  1034. void printBorn(string s, Soldier* p)
  1035. {
  1036. if (p == NULL) return;//表示没有创建
  1037. s += ' ' + p->getPrint() + " born";
  1038. puts(s.c_str());
  1039. if (p->getType() == )//is dragon
  1040. {
  1041. double t = ((Dragon*)(p))->getMorale();
  1042. //t = (double)((int)(t * 100 + 0.5)) / 100.0;//四舍五入
  1043. //oj上的测试数据并没有四舍五入。。。直接截尾取得两位有效数字,坑啊
  1044. printf("Its morale is %.2lf\n", t);
  1045. }
  1046. if (p->getType() == )//is lion
  1047. {
  1048. printf("Its loyalty is %d\n", ((Lion*)(p))->getLoyalty());
  1049. }
  1050. }
  1051. void printLionRun(string s, Lion* p)//判断lion是否逃跑以及相应信息的输出
  1052. {
  1053. p->runAway();
  1054. s += " lion " + toString(p->getId()) + " ran away";
  1055. puts(s.c_str());
  1056. }
  1057. int printMove(int c)
  1058. {
  1059. Soldier *p = NULL;
  1060. string s;
  1061. int f = ;
  1062.  
  1063. p = mAllCity[c]->RedSoldier;//red
  1064. if (p)
  1065. {
  1066. s = printNowTime() + p->getPrint();
  1067. if (c == )
  1068. s += " reached red headquarter";
  1069. else if (c == N) s += " reached blue headquarter";
  1070. else s += " marched to city " + toString(c);
  1071. s += " with " + toString(p->getBlood()) + " elements and force " + toString(p->getAttack());
  1072. puts(s.c_str());
  1073.  
  1074. if (BlueBaseInstance->occupied==&&c == N)
  1075. {
  1076. f = ;
  1077. printf("%sblue headquarter was taken\n", printNowTime().c_str());
  1078. }
  1079. }
  1080.  
  1081. p = mAllCity[c]->BlueSoldier;//blue
  1082. if (p)
  1083. {
  1084. s = printNowTime() + p->getPrint();
  1085. if (c == )
  1086. s += " reached red headquarter";
  1087. else if (c == N) s += " reached blue headquarter";
  1088. else s += " marched to city " + toString(c);
  1089. s += " with " + toString(p->getBlood()) + " elements and force " + toString(p->getAttack());
  1090. puts(s.c_str());
  1091.  
  1092. if (RedBaseInstance->occupied==&&c == )
  1093. {
  1094. f = ;
  1095. printf("%sred headquarter was taken\n", printNowTime().c_str());
  1096. }
  1097. }
  1098.  
  1099. return f;
  1100. }
  1101. int checkBomb(Soldier *p,Soldier *q,int t)//返回1即使需要使用bomb
  1102. {
  1103. //t 谁先攻击,这个应该在city中处理,0 red 1 blue
  1104. if (q->getBlood() - q->tArrow <= ) return ;
  1105. if (p->getBlood() - p->tArrow <= ) return ;
  1106. int a = , b = ,c = ,d = ;
  1107. if (t == )//p 先攻击
  1108. {
  1109. a = p->fight();
  1110. b = q->getBlood() - q->tArrow;
  1111.  
  1112. if (a < b)//q 没死 反击
  1113. {
  1114. c = q->fightback();
  1115. d = p->getBlood() - p->tArrow;
  1116. if (c >= d) return ;
  1117. }
  1118. }
  1119. else//q 先攻击
  1120. {
  1121. a = q->fight();
  1122. b = p->getBlood() - p->tArrow;
  1123.  
  1124. if (a >= b) return ;//q 打死了 p就返回1
  1125. }
  1126. return ;
  1127. }
  1128. int checkBomb2(Soldier *p, Soldier *q, int t)
  1129. {
  1130. //t 谁先攻击,这个应该在city中处理,0 red 1 blue
  1131. if (q->getBlood() - q->tArrow <= ) return ;
  1132. if (p->getBlood() - p->tArrow <= ) return ;
  1133. int a = , b = , c = , d = ;
  1134. if (t == )
  1135. {
  1136. a = p->fight();
  1137. b = q->getBlood() - q->tArrow;
  1138. if (a >= b) return ;
  1139. }
  1140. else
  1141. {
  1142. c = q->fight();
  1143. d = p->getBlood() - p->tArrow;
  1144. if (c < d)
  1145. {
  1146. a = p->fightback();
  1147. b = q->getBlood() - q->tArrow;
  1148. if (a >= b) return ;
  1149. }
  1150. }
  1151. return ;
  1152. }
  1153. int checkArrow(Soldier* p)//结算arrow的伤害并检查是否被射死了,返回1是被射死了
  1154. {
  1155. if (!p) return -;
  1156. p->loseBlood(p->tArrow);
  1157. p->tArrow = ;
  1158. if (p->getBlood() <= )
  1159. {
  1160. p->dieByArrow = ;
  1161. p->die();
  1162. return ;
  1163. }
  1164. return ;
  1165. }
  1166. int printFight(int i,Soldier *p,Soldier *q)//返回0,就是q死了
  1167. {
  1168. int a = p->fight();
  1169. int b = q->getBlood();
  1170. p->loseWeapon();//武器损耗
  1171. q->loseBlood(a);
  1172. string s = printTime();
  1173. string sp, sq;
  1174. if (p->getCamp() == ) sp = " red ";
  1175. else sp = " blue ";
  1176. if (q->getCamp() == ) sq = " red ";
  1177. else sq = " blue ";
  1178. s += sp + p->getName() + ' ' + toString(p->getId()) + " attacked" + sq;
  1179. s += q->getName() + ' ' + toString(q->getId()) + " in city " + toString(i);
  1180. s += " with " + toString(p->getBlood()) + " elements and force " + toString(p->getAttack());
  1181. //puts(s.c_str());
  1182. mAllCity[i]->output.push(s);
  1183. return q->isLive;
  1184. }
  1185. int printFightBack(int i, Soldier *p, Soldier *q)
  1186. {
  1187. if (p->getType() == )//ninjia no fightback
  1188. return ;
  1189. int a = p->fightback();
  1190. int b = q->getBlood();
  1191. p->loseWeapon();
  1192. q->loseBlood(a);
  1193. string s = printNowTime();
  1194. s += p->getPrint() + " fought back against " + q->getPrint() + " in city " + toString(i);
  1195. //puts(s.c_str());
  1196. mAllCity[i]->output.push(s);
  1197. return q->isLive;
  1198. }
  1199. void printKilled(int i,Soldier *p)
  1200. {
  1201. string s = printTime() + ' ' + p->getCampName() + ' ';
  1202. s += p->getName() + ' ' + toString(p->getId()) + " was killed in city " + toString(i);
  1203. //puts(s.c_str());
  1204. mAllCity[i]->output.push(s);
  1205. }
  1206. void afterbattle(int i, int t)//在city i 战斗结束后的事情,0 平局 1 red win 2 blue win
  1207. {
  1208. if (t == )//平局
  1209. {
  1210. mAllCity[i]->RedSoldier->drawFight(mAllCity[i]->BlueSoldier, i);
  1211. mAllCity[i]->BlueSoldier->drawFight(mAllCity[i]->RedSoldier, i);
  1212. mAllCity[i]->whoLastWin = ;
  1213. }
  1214. if (t == )//red win
  1215. {
  1216.  
  1217. mAllCity[i]->RedSoldier->winFight(mAllCity[i]->BlueSoldier, i);
  1218. mAllCity[i]->BlueSoldier->loseFight(mAllCity[i]->RedSoldier, i);
  1219. RedBaseInstance->BloodWin += mAllCity[i]->takeWinBlood(i, );
  1220. mAllCity[i]->changeFlag(i,);
  1221. }
  1222. if (t == )//blue win
  1223. {
  1224.  
  1225. mAllCity[i]->RedSoldier->loseFight(mAllCity[i]->BlueSoldier, i);
  1226. mAllCity[i]->BlueSoldier->winFight(mAllCity[i]->RedSoldier, i);
  1227. BlueBaseInstance->BloodWin += mAllCity[i]->takeWinBlood(i, );
  1228. mAllCity[i]->changeFlag(i,);
  1229. }
  1230. }
  1231. void redReward()
  1232. {
  1233. for (int i = N - ; i > ; i--)//red reward
  1234. {
  1235. if (!mAllCity[i]->RedSoldier) continue;
  1236. while (mAllCity[i]->RedSoldier->BloodWin>)
  1237. if (RedBaseInstance->Blood >= )
  1238. {
  1239. RedBaseInstance->Blood -= ;
  1240. mAllCity[i]->RedSoldier->Blood += ;
  1241. mAllCity[i]->RedSoldier->BloodWin -= ;
  1242. mAllCity[i]->redReward = ;
  1243. }
  1244. //mAllCity[i]->RedSoldier->BloodWin = 0;
  1245. }
  1246. }
  1247. void blueReward()
  1248. {
  1249. for (int i = ; i < N; i++)//blue reward
  1250. {
  1251. if (!mAllCity[i]->BlueSoldier) continue;
  1252. while (mAllCity[i]->BlueSoldier->BloodWin>)
  1253. if (BlueBaseInstance->Blood >= )
  1254. {
  1255. BlueBaseInstance->Blood -= ;
  1256. mAllCity[i]->BlueSoldier->Blood += ;
  1257. mAllCity[i]->BlueSoldier->BloodWin -= ;
  1258. mAllCity[i]->blueReward = ;
  1259. }
  1260. //mAllCity[i]->BlueSoldier->BloodWin = 0;
  1261. }
  1262. }
  1263.  
  1264. void Game()//游戏进程
  1265. {
  1266. CurrentTime = -;
  1267. Soldier *RedOccSoldier = NULL;
  1268. Soldier *BlueOccSoldier = NULL;
  1269. while (CurrentTime <= T)
  1270. {
  1271. CurrentTime++;
  1272. if (CurrentTime > T) return;
  1273. int CurrentMinute = CurrentTime % ;
  1274. string st = printTime();
  1275. switch (CurrentMinute)
  1276. {
  1277. case :
  1278. {
  1279. string s = st;
  1280. //red
  1281. Soldier* p = RedBaseInstance->CreatSoldier();
  1282. printBorn(s, p);
  1283.  
  1284. //blue
  1285. p = BlueBaseInstance->CreatSoldier();
  1286. printBorn(s, p);
  1287.  
  1288. break;
  1289. }
  1290. case :
  1291. {
  1292. for (int i = ; i <= N; i++)//从西向东
  1293. {
  1294. //red
  1295. if (mAllCity[i]->RedSoldier&&mAllCity[i]->RedSoldier->getType() == )//is lion
  1296. if (i != N)//not at bluebase
  1297. {
  1298. Lion *p = (Lion *)mAllCity[i]->RedSoldier;
  1299. string s = st;
  1300. s += " red";
  1301. if (p->getLoyalty() <= )
  1302. {
  1303. printLionRun(s, p);
  1304. mAllCity[i]->RedSoldier = NULL;
  1305. }
  1306. }
  1307.  
  1308. //blue
  1309. if (mAllCity[i]->BlueSoldier&&mAllCity[i]->BlueSoldier->getType() == )//is lion
  1310. if (i != )//not at redbase
  1311. {
  1312. Lion *p = (Lion *)mAllCity[i]->BlueSoldier;
  1313. string s = st;
  1314. s += " blue";
  1315. if (p->getLoyalty() <= )
  1316. {
  1317. printLionRun(s, p);
  1318. mAllCity[i]->BlueSoldier = NULL;
  1319. }
  1320. }
  1321. }
  1322. break;
  1323. }
  1324. case :
  1325. {
  1326. int f = ;//1即为占领了
  1327.  
  1328. //red
  1329. for (int i = N; i > ; i--)
  1330. {
  1331. if (i == N && mAllCity[N]->RedSoldier) RedOccSoldier = mAllCity[N]->RedSoldier;
  1332. mAllCity[i]->RedSoldier = mAllCity[i - ]->RedSoldier;
  1333. if (mAllCity[i]->RedSoldier&&mAllCity[i]->RedSoldier->getType() == )
  1334. {
  1335. ((Iceman*)mAllCity[i]->RedSoldier)->Move();
  1336. }
  1337. }
  1338. mAllCity[]->RedSoldier = NULL;
  1339. if (mAllCity[N]->RedSoldier) { BlueBaseInstance->occupied++; }
  1340.  
  1341. //blue
  1342. for (int i = ; i < N; i++)
  1343. {
  1344. if (i == && mAllCity[]->BlueSoldier) BlueOccSoldier = mAllCity[]->BlueSoldier;
  1345. mAllCity[i]->BlueSoldier = mAllCity[i + ]->BlueSoldier;
  1346. if (mAllCity[i]->BlueSoldier&&mAllCity[i]->BlueSoldier->getType() == )
  1347. {
  1348. ((Iceman*)mAllCity[i]->BlueSoldier)->Move();
  1349. }
  1350. }
  1351. mAllCity[N]->BlueSoldier = NULL;
  1352. if (mAllCity[]->BlueSoldier) RedBaseInstance->occupied++;
  1353. for (int i = ; i <= N; i++)
  1354. {
  1355. if (printMove(i)) f = ;
  1356. }
  1357.  
  1358. //be occupied?
  1359. if (f) return;
  1360. break;
  1361. }
  1362. case :
  1363. {
  1364. for (int i = ; i < N; i++)//不包括红蓝司令部
  1365. {
  1366. mAllCity[i]->addBlood();
  1367. }
  1368. /*RedBaseInstance->Blood += 10;
  1369. BlueBaseInstance->Blood += 10;*/
  1370. break;
  1371. }
  1372. case :
  1373. {
  1374. for (int i = ; i < N; i++)
  1375. {
  1376. if (mAllCity[i]->RedSoldier != NULL&&mAllCity[i]->BlueSoldier == NULL)
  1377. RedBaseInstance->Blood += mAllCity[i]->takeBlood();
  1378. if (mAllCity[i]->RedSoldier == NULL&&mAllCity[i]->BlueSoldier != NULL)
  1379. BlueBaseInstance->Blood += mAllCity[i]->takeBlood();
  1380. }
  1381. break;
  1382. }
  1383. case :
  1384. {
  1385. //red
  1386. for (int i = ; i < N; i++)
  1387. {
  1388. Soldier *p = mAllCity[i]->RedSoldier;
  1389. //if (!p) continue;
  1390. if (i < N-)
  1391. {
  1392. if (p&&p->hasArrow)
  1393. {
  1394. Arrow *q = p->hasArrow;
  1395. if (mAllCity[i + ]->BlueSoldier)
  1396. {
  1397. mAllCity[i + ]->BlueSoldier->tArrow += R;
  1398.  
  1399. if (q->lose() == )//返回值为0说明arrow已经消失
  1400. {
  1401. //delete q;
  1402. int t = p->getType();
  1403. switch (t)
  1404. {
  1405. case :
  1406. {
  1407. ((Dragon *)p)->mWeapon = NULL;
  1408. break;
  1409. }
  1410. case :
  1411. {
  1412. if (((Ninja *)p)->mWeapon1 && ((Ninja *)p)->mWeapon1->getType() == ) ((Ninja *)p)->mWeapon1 = NULL;
  1413. if (((Ninja *)p)->mWeapon2 && ((Ninja *)p)->mWeapon2->getType() == ) ((Ninja *)p)->mWeapon2 = NULL;
  1414. break;
  1415. }
  1416. case :
  1417. {
  1418. ((Iceman *)p)->mWeapon = NULL;
  1419. break;
  1420. }
  1421. case :
  1422. {
  1423. ((Wolf *)p)->arrowWeapon = NULL;
  1424. break;
  1425. }
  1426. }
  1427. p->hasArrow = NULL;
  1428. }
  1429. string s = st + " red ";
  1430. s += mAllCity[i]->RedSoldier->getName() + ' ' + toString(mAllCity[i]->RedSoldier->getId()) + " shot";
  1431. if (mAllCity[i + ]->BlueSoldier&&mAllCity[i + ]->BlueSoldier->getBlood() <= R)
  1432. s += " and killed blue " + mAllCity[i + ]->BlueSoldier->getName() + ' ' + toString(mAllCity[i + ]->BlueSoldier->getId());
  1433. puts(s.c_str());
  1434. }
  1435. }
  1436. }
  1437. //blue
  1438. if (i > )
  1439. {
  1440. Soldier *p = mAllCity[i]->BlueSoldier;
  1441. //if (!p) continue;
  1442. if (p&&p->hasArrow)
  1443. {
  1444. Arrow *q = p->hasArrow;
  1445. if (mAllCity[i - ]->RedSoldier)
  1446. {
  1447. mAllCity[i - ]->RedSoldier->tArrow += R;
  1448. if (q->lose() == )//返回值为0说明arrow已经消失
  1449. {
  1450. //delete q;
  1451. int t = p->getType();
  1452. switch (t)
  1453. {
  1454. case :
  1455. {
  1456. ((Dragon *)p)->mWeapon = NULL;
  1457. break;
  1458. }
  1459. case :
  1460. {
  1461. if (((Ninja *)p)->mWeapon1 && ((Ninja *)p)->mWeapon1->getType() == ) ((Ninja *)p)->mWeapon1 = NULL;
  1462. if (((Ninja *)p)->mWeapon2 && ((Ninja *)p)->mWeapon2->getType() == ) ((Ninja *)p)->mWeapon2 = NULL;
  1463. break;
  1464. }
  1465. case :
  1466. {
  1467. ((Iceman *)p)->mWeapon = NULL;
  1468. break;
  1469. }
  1470. case :
  1471. {
  1472. ((Wolf *)p)->arrowWeapon = NULL;
  1473. break;
  1474. }
  1475. }
  1476. p->hasArrow = NULL;
  1477. }
  1478. string s = st + " blue ";
  1479. s += mAllCity[i]->BlueSoldier->getName() + ' ' + toString(mAllCity[i]->BlueSoldier->getId()) + " shot";
  1480. if (mAllCity[i - ]->RedSoldier&&mAllCity[i - ]->RedSoldier->getBlood() <= R)
  1481. s += " and killed red " + mAllCity[i - ]->RedSoldier->getName() + ' ' + toString(mAllCity[i - ]->RedSoldier->getId());
  1482. puts(s.c_str());
  1483. }
  1484. }
  1485. }
  1486. }
  1487.  
  1488. break;
  1489. }
  1490. case :
  1491. {
  1492. for (int i = ; i < N; i++)
  1493. {
  1494. string s = st;
  1495. Soldier *p = mAllCity[i]->RedSoldier;
  1496. if (p&&p->hasBomb)
  1497. {
  1498. if (mAllCity[i]->BlueSoldier&&checkBomb(p,mAllCity[i]->BlueSoldier,mAllCity[i]->whoFirst))
  1499. {
  1500. p->loseWeapon();
  1501. s = st;
  1502. s += " red "+p->getName()+' '+toString(p->getId())+" used a bomb and killed blue ";
  1503. s += mAllCity[i]->BlueSoldier->getName()+' '+toString(mAllCity[i]->BlueSoldier->getId());
  1504. puts(s.c_str());
  1505. p->die();
  1506. mAllCity[i]->BlueSoldier->die();
  1507. mAllCity[i]->RedSoldier = NULL;
  1508. mAllCity[i]->BlueSoldier = NULL;
  1509. }
  1510. }
  1511.  
  1512. s = st;
  1513. p = mAllCity[i]->BlueSoldier;
  1514. if (p&&p->hasBomb)
  1515. {
  1516. if (mAllCity[i]->RedSoldier&&checkBomb2(mAllCity[i]->RedSoldier,p, mAllCity[i]->whoFirst))
  1517. {
  1518. p->loseWeapon();
  1519. s = st;
  1520. s += " blue " + p->getName() + ' ' + toString(p->getId()) + " used a bomb and killed red ";
  1521. s += mAllCity[i]->RedSoldier->getName() + ' ' + toString(mAllCity[i]->RedSoldier->getId());
  1522. puts(s.c_str());
  1523. p->die();
  1524. mAllCity[i]->RedSoldier->die();
  1525. mAllCity[i]->RedSoldier = NULL;
  1526. mAllCity[i]->BlueSoldier = NULL;
  1527. }
  1528. }
  1529.  
  1530. }
  1531. break;
  1532. }
  1533. case :
  1534. {
  1535. for (int i = ; i < N; i++)//记录lion战斗前的blood
  1536. {
  1537. if (mAllCity[i]->RedSoldier&&mAllCity[i]->RedSoldier->getType() == )
  1538. ((Lion *)mAllCity[i]->RedSoldier)->moveBlood();
  1539. if (mAllCity[i]->BlueSoldier&&mAllCity[i]->BlueSoldier->getType() == )
  1540. ((Lion *)mAllCity[i]->BlueSoldier)->moveBlood();
  1541. }
  1542. for (int i = ; i < N; i++)
  1543. {
  1544. //先处理arrow事件
  1545. int r = checkArrow(mAllCity[i]->RedSoldier);
  1546. int b = checkArrow(mAllCity[i]->BlueSoldier);
  1547. if (r == - || b == -)
  1548. {
  1549. if (r==) mAllCity[i]->RedSoldier = NULL;
  1550. if (b==) mAllCity[i]->BlueSoldier = NULL;
  1551. continue;//no fight
  1552. }
  1553. if (r == && b == ) { mAllCity[i]->RedSoldier = NULL; mAllCity[i]->BlueSoldier = NULL; }//all die,no fight
  1554. if (r == && b == ) { afterbattle(i, ); mAllCity[i]->BlueSoldier = NULL; redReward(); }//blue die,red win
  1555. if (r == && b == ) { afterbattle(i, ); mAllCity[i]->RedSoldier = NULL; blueReward(); }//blue win
  1556.  
  1557. if (r == && b == )//all not die,begin to fight
  1558. {
  1559. int t = mAllCity[i]->whoFirst;
  1560. if (t == )//red attack,blue fightback
  1561. {
  1562. int tmp = printFight(i, mAllCity[i]->RedSoldier, mAllCity[i]->BlueSoldier);
  1563. if (tmp)//没杀死,等待反击
  1564. {
  1565. int tmp2=printFightBack(i, mAllCity[i]->BlueSoldier, mAllCity[i]->RedSoldier);
  1566. if (tmp2)//反击没死,平局
  1567. {
  1568. afterbattle(i, );
  1569. }
  1570. else// blue win
  1571. {
  1572. printKilled(i, mAllCity[i]->RedSoldier);
  1573. afterbattle(i, );
  1574. mAllCity[i]->RedSoldier = NULL;
  1575. }
  1576. }
  1577. else//杀死了,red win
  1578. {
  1579. printKilled(i, mAllCity[i]->BlueSoldier);
  1580. afterbattle(i, );
  1581. mAllCity[i]->BlueSoldier = NULL;
  1582. }
  1583. }
  1584. else
  1585. {
  1586. int tmp = printFight(i, mAllCity[i]->BlueSoldier, mAllCity[i]->RedSoldier);
  1587. if (tmp)//没杀死,等待反击
  1588. {
  1589. int tmp2 = printFightBack(i, mAllCity[i]->RedSoldier, mAllCity[i]->BlueSoldier);
  1590. if (tmp2)//反击没死,平局
  1591. {
  1592. afterbattle(i, );
  1593. }
  1594. else// red win
  1595. {
  1596. printKilled(i, mAllCity[i]->BlueSoldier);
  1597. afterbattle(i, );
  1598. mAllCity[i]->BlueSoldier = NULL;
  1599. }
  1600. }
  1601. else//杀死了,blue win
  1602. {
  1603. printKilled(i, mAllCity[i]->RedSoldier);
  1604. afterbattle(i, );
  1605. mAllCity[i]->RedSoldier = NULL;
  1606. }
  1607. }
  1608. }
  1609. }
  1610. redReward();
  1611. blueReward();
  1612. RedBaseInstance->tackBloodWin();
  1613. BlueBaseInstance->tackBloodWin();
  1614. for (int i = ; i < N; i++)//output
  1615. {
  1616. while (!mAllCity[i]->output.empty())
  1617. {
  1618. puts(mAllCity[i]->output.front().c_str());
  1619. mAllCity[i]->output.pop();
  1620. }
  1621. /*if (mAllCity[i]->redReward)
  1622. {
  1623. mAllCity[i]->redReward = 0;
  1624. string s = printNowTime() + mAllCity[i]->RedSoldier->getPrint() + " earned 8 elements for his headquarter";
  1625. puts(s.c_str());
  1626. }
  1627. if (mAllCity[i]->blueReward)
  1628. {
  1629. mAllCity[i]->blueReward = 0;
  1630. string s = printNowTime() + mAllCity[i]->BlueSoldier->getPrint() + " earned 8 elements for his headquarter";
  1631. puts(s.c_str());
  1632. }*/
  1633. if (mAllCity[i]->FlagRaise == && mAllCity[i]->lastPrintFlag!=)
  1634. {
  1635. mAllCity[i]->FlagRaise = ;
  1636. mAllCity[i]->lastPrintFlag = ;
  1637. string s = printNowTime() + "red flag raised in city " + toString(i);
  1638. puts(s.c_str());
  1639. }
  1640. if (mAllCity[i]->FlagRaise == && mAllCity[i]->lastPrintFlag!=)
  1641. {
  1642. mAllCity[i]->FlagRaise = ;
  1643. mAllCity[i]->lastPrintFlag = ;
  1644. string s = printNowTime() + "blue flag raised in city " + toString(i);
  1645. puts(s.c_str());
  1646. }
  1647. }
  1648. break;
  1649. }
  1650. case :
  1651. {
  1652. string s = printNowTime() + toString(RedBaseInstance->Blood) + " elements in red headquarter";
  1653. puts(s.c_str());
  1654. s = printNowTime() + toString(BlueBaseInstance->Blood) + " elements in blue headquarter";
  1655. puts(s.c_str());
  1656. break;
  1657. }
  1658. case :
  1659. {
  1660. for (int i = ; i <= N; i++)
  1661. {
  1662. if (mAllCity[i]->RedSoldier)
  1663. {
  1664. mAllCity[i]->RedSoldier->printWeapon();
  1665. }
  1666. }
  1667. if (RedOccSoldier) RedOccSoldier->printWeapon();
  1668. if (BlueOccSoldier) BlueOccSoldier->printWeapon();
  1669. for (int i = ; i <= N; i++)
  1670. {
  1671. if (mAllCity[i]->BlueSoldier)
  1672. {
  1673. mAllCity[i]->BlueSoldier->printWeapon();
  1674. }
  1675. }
  1676. break;
  1677. }
  1678. }
  1679. }
  1680. }
  1681. int main()
  1682. {
  1683. int t;
  1684. cin >> t;
  1685. int c = ;
  1686. while (t--)
  1687. {
  1688. cout << "Case " << ++c << ":" << endl;
  1689. Init();
  1690. Game();
  1691. }
  1692. system("pause");
  1693. return ;
  1694. }
  1695.  
  1696. void Sword::init()
  1697. {
  1698. //Attack = mAllSoldier[Belong]->getAttack()*0.2;
  1699. }
  1700. void Lion::init()
  1701. {
  1702. if (getCamp() == ) {
  1703. Loyalty = RedBaseInstance->Blood;
  1704. }
  1705. else {
  1706. Loyalty = BlueBaseInstance->Blood;
  1707. }
  1708. }
  1709. void getWeapon(Soldier * t,Weapon* &p, int code)
  1710. {
  1711. switch (code)
  1712. {
  1713. case :
  1714. {
  1715. p = new Sword();
  1716. ((Sword *)p)->init();
  1717. ((Sword *)p)->setAttack(t->getAttack());
  1718. if (p->getAttack() == )
  1719. {
  1720. delete p;
  1721. p = NULL;
  1722. }
  1723. break;
  1724. }
  1725. case :
  1726. {
  1727. p = new Bomb();
  1728. ((Bomb *)p)->init();
  1729. t->hasBomb = ((Bomb *)p);
  1730. break;
  1731. }
  1732. case :
  1733. {
  1734. p = new Arrow();
  1735. ((Arrow *)p)->init();
  1736. t->hasArrow = ((Arrow *)p);
  1737. break;
  1738. }
  1739. }
  1740. //p->setBelong(getuId());//设置属于谁的
  1741. }
  1742. void Dragon::init()
  1743. {
  1744. getWeapon(this,mWeapon, Id % );
  1745. if(mWeapon) mWeapon->setBelong(getuId());//设置属于谁的
  1746. if (Camp == )//3.初始化morale
  1747. {
  1748. Morale = (double)RedBaseInstance->Blood / (double)SoldierBlood[];
  1749. }
  1750. else
  1751. {
  1752. Morale = (double)BlueBaseInstance->Blood / (double)SoldierBlood[];
  1753. }
  1754. }
  1755. Soldier* Base::CreatSoldier()
  1756. {
  1757. Soldier *tmp=NULL;
  1758. switch (creatwho(SoidierNum))
  1759. {
  1760. case ://iceman
  1761. tmp = new Iceman();
  1762. break;
  1763. case ://lion
  1764. tmp = new Lion();
  1765. break;
  1766. case ://wolf
  1767. tmp = new Wolf();
  1768. break;
  1769. case ://ninja
  1770. tmp = new Ninja();
  1771. break;
  1772. case ://dragon
  1773. tmp = new Dragon();
  1774. break;
  1775. }
  1776. if (tmp->getBlood() <= Blood)//可以制造出生命值为 m 的武士
  1777. {
  1778. Blood -= tmp->getBlood();
  1779. SoidierNum++;
  1780. tmp->setCamp(getCamp());
  1781. tmp->setId(SoidierNum);
  1782. tmp->init();
  1783. mSoldier.push_back(tmp);
  1784. mAllSoldier.push_back(tmp);
  1785.  
  1786. if (getCamp() == )
  1787. {
  1788. mAllCity[]->RedSoldier = tmp;
  1789. }
  1790. else
  1791. {
  1792. mAllCity[N]->BlueSoldier = tmp;
  1793. }
  1794. return tmp;
  1795. }
  1796. else
  1797. {
  1798. delete tmp;//
  1799. return NULL;
  1800. }
  1801. }
  1802.  
  1803. void Dragon::yell(int t)//judge whether to yell
  1804. {
  1805. if (mAllCity[t]->whoFirst == Camp)//检测是否先攻击
  1806. {
  1807. if (Morale > 0.8)
  1808. {
  1809. string s = printTime();
  1810. if (Camp == ) s += " red ";
  1811. if (Camp == ) s += " blue ";
  1812. s += getName() + ' ' + toString(getId())+" yelled in city "+toString(t);
  1813. mAllCity[t]->output.push(s);
  1814. //puts(s.c_str());
  1815. }
  1816. }
  1817. }

coursera_poj_魔兽世界终结版的更多相关文章

  1. IOS之UI--小实例项目--添加商品和商品名(使用xib文件终结版) + xib相关知识点总结

    添加商品和商品名小项目(使用xib文件终结版) 小贴士:博文末尾有项目源码在百度云备份的下载链接. xib相关知识点总结 01-基本使用 一开始使用xib的时候,如果要使用自定义view的代码,就需要 ...

  2. Qt Windows下链接子系统与入口函数(终结版)(可同时存在main和WinMain函数)

    Qt Windows下链接子系统与入口函数(终结版) 转载自:http://blog.csdn.net/dbzhang800/article/details/6358996 能力所限,本讨论仅局限于M ...

  3. 蜻蜓特派员 Windows XP SP3 纯净终结版

    蜻蜓特派员Windows XP SP3 纯净安装版 终结版,系统纯净无广告.无插件,网卡等驱动和运行库齐全,安全更新补丁全网最新!微软停止了 Windows XP 的支持之后还是偶尔为 WinXP 提 ...

  4. [转]springcloud(九):配置中心和消息总线(配置中心终结版)

    https://www.cnblogs.com/ityouknow/p/6931958.html springcloud(九):配置中心和消息总线(配置中心终结版) 我们在springcloud(七) ...

  5. SQL Server数据全同步及价值分析[终结版]

    SQL Server数据全同步[终结版] 版权全部.转载请注明出处.谢谢! 经过两天的同步编写和測试.出了第一个Release版本号: 1. 本函数仅支持单向同步.即从一个主数据库想多个从数据库同步 ...

  6. 马后炮之12306抢票工具(四)--抢票Demo,2014年1月9日终结版

    时隔一年多,终于朋友的忽悠下吧抢票Demo的最后一步完善了,与2014年1月9日成功生成车票. Demo仅经过自己测试,并未在高峰期进行测试,代码质量很差,因为赶工,套用去年模板并未使用设计模式. 代 ...

  7. Qt编写输入法V2018超级终结版

    对于qt嵌入式linux开发人员来说,输入法一直是个鸡肋问题,要么不支持实体键盘同步,要么不能汉字输入,要么不支持网页输入等,这几年通过陆续接触大量的各种输入法应用场景客户,得到真实需求,不断改进,最 ...

  8. R:魔兽世界终极版

    描述 魔兽世界的西面是红魔军的司令部,东面是蓝魔军的司令部.两个司令部之间是依次排列的若干城市,城市从西向东依次编号为1,2,3 .... N ( N <= 20 ).红魔军的司令部算作编号为0 ...

  9. CSS布局解决方案(终结版)

    作者:无悔铭 https://segmentfault.com/a/1190000013565024 前端布局非常重要的一环就是页面框架的搭建,也是最基础的一环.在页面框架的搭建之中,又有居中布局.多 ...

随机推荐

  1. 201521123036 《Java程序设计》第3周学习总结

    本周学习总结 初学面向对象,会学习到很多碎片化的概念与知识.尝试学会使用思维导图将这些碎片化的概念.知识组织起来. 书面作业 Q1:代码阅读 public class Test1 { private ...

  2. 201521123070 《JAVA程序设计》第3周学习总结

    1. 本章学习总结 初学面向对象,会学习到很多碎片化的概念与知识.尝试学会使用思维导图将这些碎片化的概念.知识组织起来.请使用纸笔或者下面的工具画出本周学习到的知识点.截图或者拍照上传. http:/ ...

  3. Sublime使用Ctrl+`作为快捷键弹出Console没有反映的解决办法

    很多Sublime新人都遇到了这个问题,到网上搜,信息很片面,而且不少都是旧版本的.于是有了这篇文章.       默认Sublime使用Ctrl+`作为快捷键弹出Console,但不同的系统抑或安装 ...

  4. 控制结构(7) 程序计数器(PC)

    // 上一篇:最近最少使用(LRU) // 下一篇:线性化(linearization) 程序的每一行都是一个状态,对应的行指令.同步的情况下同一个pc一直自增,异步的时候,分裂出一个新的子pc,独立 ...

  5. 201521123044 《Java程序设计》第11周学习总结

    1. 本章学习总结 2. 书面作业 本次PTA作业题集多线程 1.互斥访问与同步访问 完成题集4-4(互斥访问)与4-5(同步访问) 1.1 除了使用synchronized修饰方法实现互斥同步访问, ...

  6. 201521123028 《Java程序设计》 第9周学习总结

    1. 本周学习总结 2. 书面作业 Q1.常用异常 题目5-1 1.1 截图你的提交结果(出现学号) 1.2 自己以前编写的代码中经常出现什么异常.需要捕获吗(为什么)?应如何避免? Ans: 在JA ...

  7. 多线程面试题系列(14):读者写者问题继 读写锁SRWLock

    在第十一篇文章中我们使用事件和一个记录读者个数的变量来解决读者写者问题.问题虽然得到了解决,但代码有点复杂.本篇将介绍一种新方法--读写锁SRWLock来解决这一问题.读写锁在对资源进行保护的同时,还 ...

  8. python之socket--粘包补充

    struct补充 import struct import json header_dic={'total_size':123123, 'filename':None, 'md5':None} hea ...

  9. Java并发编程 Volatile关键字解析

    volatile关键字的两层语义 一旦一个共享变量(类的成员变量.类的静态成员变量)被volatile修饰之后,那么就具备了两层语义: 1)保证了不同线程对这个变量进行操作时的可见性,即一个线程修改了 ...

  10. Apache Spark 2.2.0 中文文档 - 概述 | ApacheCN

    Spark 概述 Apache Spark 是一个快速的, 多用途的集群计算系统. 它提供了 Java, Scala, Python 和 R 的高级 API,以及一个支持通用的执行图计算的优化过的引擎 ...