logo

libbulletml

Library of Bullet Markup Language (forked from https://shinh.skr.jp/libbulletml/index_en.html )git clone https://hacktivis.me/git/libbulletml.git

bulletmlrunnerimpl.cpp (12975B)

    

  1. #include "bulletmlrunnerimpl.h"
  2. #include "bulletmlrunner.h"
  3. #include "bulletmlparser.h"
  4. #include "bulletmlerror.h"
  5. #include "formula-variables.h"
  7. #include "auto_ptr_fix.h"
  9. #include <cassert>
  10. #include <cmath>
  12. BulletMLRunnerImpl::Method
  13. BulletMLRunnerImpl::commandMap_[BulletMLNode::nameSize] = {
  14. 	&BulletMLRunnerImpl::runBullet,
  15. 	&BulletMLRunnerImpl::runAction,
  16. 	&BulletMLRunnerImpl::runFire,
  17. 	&BulletMLRunnerImpl::runChangeDirection,
  18. 	&BulletMLRunnerImpl::runChangeSpeed,
  19. 	&BulletMLRunnerImpl::runAccel,
  20. 	&BulletMLRunnerImpl::runWait,
  21. 	&BulletMLRunnerImpl::runRepeat,
  22. 	&BulletMLRunnerImpl::runBulletRef,
  23. 	&BulletMLRunnerImpl::runActionRef,
  24. 	&BulletMLRunnerImpl::runFireRef,
  25. 	&BulletMLRunnerImpl::runVanish
  26. };
  28. double BulletMLRunnerImpl::getDirection(BulletMLNode* dirNode) {
  29.     double dir;
  31.     bool isDefault = true;
  32.     dir = getNumberContents(dirNode);
  34.     if (dirNode->getType() != BulletMLNode::none) {
  35. 		BulletMLNode::Type type = dirNode->getType();
  36. 		isDefault = false;
  38. 		if (type == BulletMLNode::absolute) {
  39. 			if (bulletml_->isHorizontal()) {
  40. 				dir -= 90;
  41. 			}
  42. 		}
  43. 		else if (type == BulletMLNode::relative) {
  44. 			dir += runner_->getBulletDirection();
  45. 		}
  46. 		else if (type == BulletMLNode::sequence) {
  47. 			if (!prevDir_.isValidate()) {
  48. 				dir = 0;
  49. 				isDefault = true;
  50. 			}
  51. 			else dir += prevDir_;
  52. 		}
  53. 		else {
  54. 			isDefault = true;
  55. 		}
  56.     }
  58.     if (isDefault) {
  59. 		// 明らかに非効率
  60. 		dir += runner_->getAimDirection();
  61.     }
  63.     while (dir > 360) dir -= 360;
  64.     while (dir < 0) dir += 360;
  66.     prevDir_ = dir;
  68.     return dir;
  69. }
  71. double BulletMLRunnerImpl::getSpeed(BulletMLNode* spdNode) {
  72.     double spd;
  74.     spd = getNumberContents(spdNode);
  75.     if (spdNode->getType() != BulletMLNode::none) {
  76. 		BulletMLNode::Type type = spdNode->getType();
  78. 		if (type == BulletMLNode::relative) {
  79. 			spd += runner_->getBulletSpeed();
  80. 		}
  81. 		else if (type == BulletMLNode::sequence) {
  82. 			if (!prevSpd_.isValidate()) spd = 1;
  83. 			else spd += prevSpd_;
  84. 		}
  85.     }
  87.     // デフォルトでは何もしない
  89.     prevSpd_ = spd;
  91.     return spd;
  92. }
  94. BulletMLRunnerImpl::BulletMLRunnerImpl(BulletMLState* state,
  95. 									   BulletMLRunner* runner)
  96. 	: bulletml_(state->getBulletML()),
  97.       node_(state->getNode().begin(), state->getNode().end()),
  98.       actIte_(0), end_(false), runner_(runner)
  99. {
  100. 	if (state->getParameter().get() != 0) {
  101. 		parameters_ = state->getParameter();
  102. 	}
  104. 	delete state;
  107. 	for (std::vector<BulletMLNode*>::iterator ite = node_.begin(); ite != node_.end(); ++ite) {
  109. 		(*ite)->setParent(0);
  111. 	}
  113. /*
  114. 	std::for_each(node_.begin(), node_.end(),
  115. 				  std::bind2nd(std::mem_fun(&BulletMLNode::setParent), 0));
  116. */
  117. 	actTurn_ = -1;
  118. 	act_ = node_[0];
  119. }
  121. BulletMLRunnerImpl::~BulletMLRunnerImpl() {}
  123. double BulletMLRunnerImpl::getNumberContents(const BulletMLNode* node) {
  124.     assert(node);
  126. 	Variables::rank = runner_->getRank();
  127. 	Variables::parameters = parameters_.get();
  128. 	Variables::runner = runner_;
  129. 	return node->getValue();
  130. }
  132. void BulletMLRunnerImpl::setSpeed() {
  133.     BulletMLNode* spd = act_->getChild(BulletMLNode::speed);
  134.     if (spd == 0) return;
  136.     spd_ = getSpeed(spd);
  137. }
  139. void BulletMLRunnerImpl::setDirection() {
  140.     BulletMLNode* dir = act_->getChild(BulletMLNode::direction);
  141.     if (dir == 0) return;
  143.     dir_ = getDirection(dir);
  144. }
  146. bool BulletMLRunnerImpl::isTurnEnd() {
  147. 	return isEnd() || actTurn_ > endTurn_;
  148. }
  150. void BulletMLRunnerImpl::doWait(int frame) {
  151. 	if (frame <= 0) return;
  152. 	actTurn_ += frame;
  153. }
  155. void BulletMLRunnerImpl::changes() {
  156. 	int now = runner_->getTurn();
  158.     if (changeDir_.get() != 0) {
  159. 		if (changeDir_->isLast(now)) {
  160. 			runner_->doChangeDirection(changeDir_->getLast());
  161. 			delete auto_ptr_release(changeDir_);
  162. 		}
  163. 		else {
  164. 			runner_->doChangeDirection(changeDir_->getValue(now));
  165. 		}
  166.     }
  168.     if (changeSpeed_.get() != 0) {
  169. 		if (changeSpeed_->isLast(now)) {
  170. 			runner_->doChangeSpeed(changeSpeed_->getLast());
  171. 			delete auto_ptr_release(changeSpeed_);
  172. 		}
  173. 		else {
  174. 			runner_->doChangeSpeed(changeSpeed_->getValue(now));
  175. 		}
  176.     }
  178.     if (accelx_.get() != 0) {
  179. 		if (accelx_->isLast(now)) {
  180. 			runner_->doAccelX(accelx_->getLast());
  181. 			delete auto_ptr_release(accelx_);
  182. 		}
  183. 		else {
  184. 			runner_->doAccelX(accelx_->getValue(now));
  185. 		}
  186.     }
  188.     if (accely_.get() != 0) {
  189. 		if (accely_->isLast(now)) {
  190. 			runner_->doAccelY(accely_->getLast());
  191. 			delete auto_ptr_release(accely_);
  192. 		}
  193. 		else {
  194. 			runner_->doAccelY(accely_->getValue(now));
  195. 		}
  196.     }
  197. }
  199. void BulletMLRunnerImpl::runSub() {
  200. 	// 見たくもないコードだね。
  201. 	while (act_ != 0 && !isTurnEnd()) {
  202. 		BulletMLNode* prev = act_;
  203. 		Method fp = commandMap_[act_->getName()];
  204. 		(this->*fp)();
  206. 		// ref から戻る
  207. 		if (act_ == 0 &&
  208. 			prev->getParent() != 0 &&
  209. 			prev->getParent()->getName() == BulletMLNode::bulletml)
  210. 		{
  211. 			assert(!refStack_.empty());
  212. 			prev = refStack_.top().first;
  213. 			parameters_ = refStack_.top().second;
  214. 			refStack_.pop();
  215. 		}
  217. 		// 次の node を探す
  218. 		if (act_ == 0) act_ = prev->next();
  220. 		// 上に遡って次の node を探す
  221. 		while (act_ == 0) {
  222. 			if (prev->getParent() != 0 &&
  223. 				prev->getParent()->getName() == BulletMLNode::repeat)
  224. 			{
  225. 				RepeatElem* rep = repeatStack_.top();
  226. 				rep->ite++;
  227. 				if (rep->ite < rep->end) {
  228. 					act_ = rep->act;
  229. 					break;
  230. 				}
  231. 				else {
  232. 					delete rep;
  233. 					repeatStack_.pop();
  234. 				}
  235. 			}
  237. 			act_ = prev->getParent();
  238. 			if (act_ == 0) break;
  240. 			prev = act_;
  242. 			if (prev->getParent() != 0 &&
  243. 				prev->getParent()->getName() == BulletMLNode::bulletml)
  244. 			{
  245. 				assert(!refStack_.empty());
  246. 				prev = act_ = refStack_.top().first;
  247. 				parameters_ = refStack_.top().second;
  248. 				refStack_.pop();
  249. 			}
  251. 			act_ = act_->next();
  252. 		}
  253. 	}
  254. }
  256. void BulletMLRunnerImpl::run() {
  257. 	if (isEnd()) return;
  259. 	changes();
  261. 	endTurn_ = runner_->getTurn();
  263. 	// 最後の wait, change系を待つだけ
  264. 	if (act_ == 0) {
  265. 		if (!isTurnEnd()) {
  266. 			if (changeDir_.get() == 0 && changeSpeed_.get() == 0 &&
  267. 				accelx_.get() == 0 && accely_.get() == 0)
  268. 			{
  269. 				end_ = true;
  270. 			}
  271. 		}
  272. 		return;
  273. 	}
  275. 	act_ = node_[actIte_];
  276. 	if (actTurn_ == -1) actTurn_ = runner_->getTurn();
  278. 	runSub();
  280. 	if (act_ == 0) {
  281. 		actIte_++;
  282. 		if (node_.size() != actIte_) act_ = node_[actIte_];
  283. 	}
  284. 	else {
  285. 		node_[actIte_] = act_;
  286. 	}
  287. }
  289. void BulletMLRunnerImpl::runBullet() {
  290. 	setSpeed();
  291. 	setDirection();
  292. 	if (!spd_.isValidate()) {
  293. 		prevSpd_ = spd_ = runner_->getDefaultSpeed();
  294. 	}
  295. 	if (!dir_.isValidate()) {
  296. 		prevDir_ = dir_ = runner_->getAimDirection();
  297. 	}
  299. 	if (act_->getChild(BulletMLNode::action) == 0 &&
  300. 		act_->getChild(BulletMLNode::actionRef) == 0) {
  301. 		runner_->createSimpleBullet(dir_, spd_);
  302. 	}
  303. 	else {
  304. 		std::vector<BulletMLNode*> acts;
  305. 		act_->getAllChildrenVec(BulletMLNode::action, acts);
  307. 		act_->getAllChildrenVec(BulletMLNode::actionRef, acts);
  309. /*
  311. 		act_->getAllChildren(BulletMLNode::action, std::back_inserter(acts));
  313. 		act_->getAllChildren(BulletMLNode::actionRef,
  315. 							 std::back_inserter(acts));
  317. */
  319. 		BulletMLState* state = new BulletMLState(bulletml_, acts, parameters_);
  321. 		runner_->createBullet(state, dir_, spd_);
  322. 	}
  324. 	act_ = 0;
  325. }
  327. void BulletMLRunnerImpl::runFire() {
  328. 	shotInit();
  330. 	setSpeed();
  331. 	setDirection();
  333. 	BulletMLNode* bullet = act_->getChild(BulletMLNode::bullet);
  334. 	if (bullet == 0) bullet = act_->getChild(BulletMLNode::bulletRef);
  335. 	BulletMLError::doAssert(bullet != 0,
  336. 							"<fire> must have contents bullet or bulletRef");
  338. 	act_ = bullet;
  339. }
  341. void BulletMLRunnerImpl::runAction() {
  342. 	if (act_->childSize() == 0) act_ = 0;
  343. 	else act_ = *act_->childBegin();
  344. }
  346. void BulletMLRunnerImpl::runWait() {
  347. 	int frame = static_cast<int>(getNumberContents(act_));
  348. 	doWait(frame);
  350. 	act_ = 0;
  351. }
  353. void BulletMLRunnerImpl::runRepeat() {
  354. 	const BulletMLNode* times = act_->getChild(BulletMLNode::times);
  355. 	if (times == 0) return;
  357. 	int timesNum = static_cast<int>(getNumberContents(times));
  359. 	BulletMLNode* action = act_->getChild(BulletMLNode::action);
  360. 	if (action == 0) action = act_->getChild(BulletMLNode::actionRef);
  361. 	BulletMLError::doAssert(
  362. 		action != 0,
  363. 		"repeat elem must have contents action or actionRef");
  365. 	repeatStack_.push(new RepeatElem(0, timesNum, action));
  367. 	act_ = action;
  368. }
  370. void BulletMLRunnerImpl::runFireRef() {
  371. 	std::shared_ptr<Parameters> prevPara = parameters_;
  372. 	parameters_.reset(getParameters());
  374. 	refStack_.push(std::make_pair(act_, prevPara));
  375. 	act_ = bulletml_->getFireRef(act_->getRefID());
  376. }
  378. void BulletMLRunnerImpl::runActionRef() {
  379. 	std::shared_ptr<Parameters> prevPara = parameters_;
  380. 	parameters_.reset(getParameters());
  382. 	refStack_.push(std::make_pair(act_, prevPara));
  383. 	act_ = bulletml_->getActionRef(act_->getRefID());
  384. }
  386. void BulletMLRunnerImpl::runBulletRef() {
  387. 	std::shared_ptr<Parameters> prevPara = parameters_;
  388. 	parameters_.reset(getParameters());
  390. 	refStack_.push(std::make_pair(act_, prevPara));
  391. 	act_ = bulletml_->getBulletRef(act_->getRefID());
  392. }
  394. void BulletMLRunnerImpl::runChangeDirection() {
  395. 	int term = static_cast<int>(getNumberContents(
  396. 									act_->getChild(BulletMLNode::term)));
  397. 	BulletMLNode* dirNode = act_->getChild(BulletMLNode::direction);
  398. 	BulletMLNode::Type type = dirNode->getType();
  400. 	double dir;
  401. 	if (type != BulletMLNode::sequence) dir = getDirection(dirNode);
  402. 	else dir = getNumberContents(dirNode);
  404. 	calcChangeDirection(dir, term, type == BulletMLNode::sequence);
  406. 	act_ = 0;
  407. }
  409. void BulletMLRunnerImpl::runChangeSpeed() {
  410. 	int term = static_cast<int>(getNumberContents(
  411. 									act_->getChild(BulletMLNode::term)));
  412. 	BulletMLNode* spdNode = act_->getChild(BulletMLNode::speed);
  413. 	BulletMLNode::Type type = spdNode->getType();
  415. 	double spd;
  416. 	if (type != BulletMLNode::sequence) spd = getSpeed(spdNode);
  417. 	else {
  418. 		spd = getNumberContents(spdNode) * (double)term
  419. 			+ runner_->getBulletSpeed();
  420. 	}
  421. 	
  423. 	calcChangeSpeed(spd, term);
  425. 	act_ = 0;
  426. }
  428. void BulletMLRunnerImpl::runAccel() {
  429. 	int term = static_cast<int>(getNumberContents(
  430. 									act_->getChild(BulletMLNode::term)));
  431. 	BulletMLNode* hnode = act_->getChild(BulletMLNode::horizontal);
  432. 	BulletMLNode* vnode = act_->getChild(BulletMLNode::vertical);
  434. 	if (bulletml_->isHorizontal()) {
  435. 		if (vnode != 0) calcAccelX(getNumberContents(vnode), term,
  436. 								   vnode->getType());
  437. 		if (hnode != 0) calcAccelY(-getNumberContents(hnode), term,
  438. 								   hnode->getType());
  439. 	}
  440. 	else {
  441. 		if (hnode != 0) calcAccelX(getNumberContents(hnode), term,
  442. 								   hnode->getType());
  443. 		if (vnode != 0) calcAccelY(getNumberContents(vnode), term,
  444. 								   vnode->getType());
  445. 	}
  447. 	act_ = 0;
  448. }
  450. void BulletMLRunnerImpl::calcChangeDirection(double direction, int term,
  451. 											 bool seq)
  452. {
  453. 	int finalTurn = actTurn_ + term;
  455. 	double dirFirst = runner_->getBulletDirection();
  457. 	if (seq) {
  458. 		auto_ptr_copy(changeDir_, new LinearFunc<int, double>
  459. 					  (actTurn_, finalTurn,
  460. 					   dirFirst, dirFirst + direction * term));
  461. 	}
  462. 	else {
  463. 		double dirSpace;
  465. 		// ちゃんと近い方を回っていくのは結構難しいね
  466. 		double dirSpace1 = direction - dirFirst;
  467. 		double dirSpace2;
  468. 		if (dirSpace1 > 0) dirSpace2 = dirSpace1 - 360;
  469. 		else dirSpace2 = dirSpace1 + 360;
  470. 		if (fabs(dirSpace1) < fabs(dirSpace2)) dirSpace = dirSpace1;
  471. 		else dirSpace = dirSpace2;
  473. 		auto_ptr_copy(changeDir_, new LinearFunc<int, double>
  474. 					  (actTurn_, finalTurn, dirFirst, dirFirst + dirSpace));
  475. 	}
  476. }
  478. void BulletMLRunnerImpl::calcChangeSpeed(double speed, int term) {
  479. 	int finalTurn = actTurn_ + term;
  481. 	double spdFirst = runner_->getBulletSpeed();
  483. 	auto_ptr_copy(changeSpeed_, new LinearFunc<int, double>
  484. 				  (actTurn_, finalTurn, spdFirst, speed));
  485. }
  487. void BulletMLRunnerImpl::calcAccelY(double horizontal, int term,
  488. 									BulletMLNode::Type type)
  489. {
  490. 	int finalTurn = actTurn_ + term;
  492. 	double firstSpd = runner_->getBulletSpeedY();
  493. 	double finalSpd;
  495. 	if (type == BulletMLNode::sequence) {
  496. 		finalSpd = firstSpd + horizontal * term;
  497. 	}
  498. 	else if (type == BulletMLNode::relative) {
  499. 		finalSpd = firstSpd + horizontal;
  500. 	}
  501. 	else {
  502. 		finalSpd = horizontal;
  503. 	}
  505. 	auto_ptr_copy(accely_, new LinearFunc<int, double>
  506. 				  (actTurn_, finalTurn, firstSpd, finalSpd));
  507. }
  509. void BulletMLRunnerImpl::calcAccelX(double vertical, int term,
  510. 									BulletMLNode::Type type)
  511. {
  512. 	int finalTurn = actTurn_ + term;
  514. 	double firstSpd = runner_->getBulletSpeedX();
  515. 	double finalSpd;
  517. 	if (type == BulletMLNode::sequence) {
  518. 		finalSpd = firstSpd + vertical * term;
  519. 	}
  520. 	else if (type == BulletMLNode::relative) {
  521. 		finalSpd = firstSpd + vertical;
  522. 	}
  523. 	else {
  524. 		finalSpd = vertical;
  525. 	}
  527. 	auto_ptr_copy(accelx_ ,new LinearFunc<int, double>
  528. 				  (actTurn_, finalTurn, firstSpd, finalSpd));
  529. }
  531. void BulletMLRunnerImpl::runVanish() {
  532. 	runner_->doVanish();
  534. 	act_ = 0;
  535. }
  537. BulletMLRunnerImpl::Parameters* BulletMLRunnerImpl::getParameters() {
  538. 	Parameters* para = 0;
  539. 	bool first = true;
  541. 	BulletMLNode::ChildIterator ite;
  542. 	for (ite = act_->childBegin(); ite != act_->childEnd(); ite++) {
  543. 		BulletMLNode* node = *ite;
  544. 		if (node->getName() != BulletMLNode::param) continue;
  546. 		if (first) {
  547. 			first = false;
  548. 			para = new Parameters;
  549. 			// 0番要素は使わない
  550. 			para->push_back(0);
  551. 		}
  553. 		para->push_back(getNumberContents(node));
  554. 	}
  556. 	return para;
  557. }
  559.