/**
* Add or remove waiting times from an order.
* @param tile Not used.
* @param flags Operation to perform.
* @param p1 Various bitstuffed elements
* - p1 = (bit 0-19) - Vehicle with the orders to change.
* - p1 = (bit 20-27) - Order index to modify.
* - p1 = (bit 28) - Whether to change the waiting time or the travelling
* time.
* @param p2 The amount of time to wait.
* - p2 = (bit 0-15) - Waiting or travelling time as specified by p1 bit 28
* @param text unused
* @return the cost of this operation or an error
*/
CommandCost CmdChangeTimetable(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
{
VehicleID veh = GB(p1, 0, 20);
Vehicle *v = Vehicle::GetIfValid(veh);
if (v == NULL || !v->IsPrimaryVehicle()) return CMD_ERROR;
CommandCost ret = CheckOwnership(v->owner);
if (ret.Failed()) return ret;
VehicleOrderID order_number = GB(p1, 20, 8);
Order *order = v->GetOrder(order_number);
if (order == NULL || order->IsType(OT_IMPLICIT)) return CMD_ERROR;
bool is_journey = HasBit(p1, 28);
int wait_time = order->wait_time;
int travel_time = order->travel_time;
if (is_journey) {
travel_time = GB(p2, 0, 16);
} else {
wait_time = GB(p2, 0, 16);
}
if (wait_time != order->wait_time) {
switch (order->GetType()) {
case OT_GOTO_STATION:
if (order->GetNonStopType() & ONSF_NO_STOP_AT_DESTINATION_STATION) return_cmd_error(STR_ERROR_TIMETABLE_NOT_STOPPING_HERE);
break;
case OT_CONDITIONAL:
break;
default: return_cmd_error(STR_ERROR_TIMETABLE_ONLY_WAIT_AT_STATIONS);
}
}
if (travel_time != order->travel_time && order->IsType(OT_CONDITIONAL)) return CMD_ERROR;
if (flags & DC_EXEC) {
if (wait_time != order->wait_time) ChangeTimetable(v, order_number, wait_time, false);
if (travel_time != order->travel_time) ChangeTimetable(v, order_number, travel_time, true);
}
return CommandCost();
}
void OrderBook::runOrderBook()
{
Order orderToExecute;
while(open){
if(orders.try_pop(orderToExecute)){
switch(orderToExecute.m_type)
{
case LIMIT_SELL:
//std::cout << "limit sell :" << std::endl;
processLimitSellOrder(orderToExecute);
break;
case LIMIT_BUY:
//std::cout << "limit buy : " << std::endl;
processLimitBuyOrder(orderToExecute);
break;
case MARKET_SELL:
//std::cout << "market sell" << std::endl;
processMarketSellOrder(orderToExecute);
break;
case MARKET_BUY:
//std::cout << "market buy" << std::endl;
processMarketBuyOrder(orderToExecute);
break;
case CANCEL_BUY:
//std::cout << "cancel buy" << std::endl;
processBuyCancellation(orderToExecute.m_owner, orderToExecute.m_globalOrderIdentifier, orderToExecute.getPrice(), orderToExecute.m_time);
break;
case CANCEL_SELL:
//std::cout << "cancel sell" << std::endl;
processSellCancellation(orderToExecute.m_owner, orderToExecute.m_globalOrderIdentifier, orderToExecute.getPrice(), orderToExecute.m_time);
break;
case CLEAR_OB:
/*cleanOrderBook();
setDefaultBidAsk(orderToExecute.m_newBid, orderToExecute.m_newAsk);*/
break;
default:
break;
}
m_linkToMarket->updateCurrentTime(orderToExecute.m_time);
m_linkToMarket->notifyAllAgents();
if(orderToExecute.getOwner() == 3)
nbOrderMM++;
nbOrder++;
}
}
}
bool Path::Load(pugi::xml_node const& aPathNode) {
mName = aPathNode.attribute("name").value();
mStartPosition.x = static_cast<float>(aPathNode.child("start_point").attribute("x").as_float());
mStartPosition.y = static_cast<float>(aPathNode.child("start_point").attribute("y").as_int());
for(pugi::xml_node const& aOrderNode : aPathNode.children("order")) {
Order o;
if(!o.Load(aOrderNode)) {
std::cout << "Could not load order on path" << std::endl;
assert(0);
return false;
}
mOrders.push_back(o);
}
return true;
}
OrderList PgsqlDataProvider::getOrders(OrderType type, string methodName, uint32_t stockId)
{
OrderList orderList;
nontransaction command(*conn);
string query = "SELECT id, broker_id, stock_id, amount, price FROM " + methodName + "(" + to_string(stockId) + ");";
result queryResult(command.exec(query));
if (verbose)
cout << "Result of " << query << ": " << endl;
ResultIterator endIterator = queryResult.end();
for (ResultIterator iterator = queryResult.begin(); iterator != endIterator; ++iterator)
{
Order order;
order.setId(iterator[0].as<uint64_t>());
order.setType(type);
order.setBrokerId(iterator[1].as<uint32_t>());
order.setStockId(iterator[2].as<uint32_t>());
order.setAmount(iterator[3].as<uint32_t>());
order.setPrice(Decimal(iterator[4].as<string>()));
orderList.push_back(order);
}
if (verbose)
cout << orderList.size() << " orders. " << endl;
return orderList;
}
void MainWindow::onOrderTaken() {
ui->answer->setText("^");
enableInput();
int id = factory->take_order();
if(id == -1) {
ui->orderInfo->setText("");
disableInput();
} else {
factory->remove_order(id);
Order* order = factory->get_order_in_progress();
QStringList words;
for (std::string word : order->get_words()) {
words << QString(word.c_str());
}
ui->orderInfo->setText(words.join(", "));
ui->takeOrder->setDisabled(true);
}
}
void Fleet::doOnceATurn(){
Game* game = Game::getGame();
IGObject * pob = game->getObjectManager()->getObject(obj->getParent());
uint32_t obT_Planet = game->getObjectTypeManager()->getObjectTypeByName("Planet");
if(pob->getType() == obT_Planet && ((Planet*)(pob->getObjectBehaviour()))->getOwner() == getOwner()){
IntegerObjectParam* damage = ((IntegerObjectParam*)(obj->getParameter(4,2)));
if(damage->getValue() != 0){
damage->setValue(0);
obj->touchModTime();
}
}
game->getObjectManager()->doneWithObject(obj->getParent());
Order* order = game->getOrderManager()->getOrderQueue(((OrderQueueObjectParam*)(obj->getParameter(3,1)))->getQueueId())->getFirstOrder();
if(order == NULL || order->getType() != game->getOrderManager()->getOrderTypeByName("Move")){
setVelocity(Vector3d(0,0,0));
}
}
void OrderMatcher::matchOrders(TradeList& tradeList, OrderList& buyList, OrderList& sellList, Decimal price)
{
if (verbose)
cout << endl << "Matching orders..." << endl;
if (buyList.size() == 0 || sellList.size() == 0)
return;
Order buyOrder = buyList.front();
Order sellOrder = sellList.front();
bool finished = false;
while (!finished && buyOrder.getPrice() >= price && sellOrder.getPrice() <= price)
{
uint32_t amount = std::min(buyOrder.getAmount(), sellOrder.getAmount());
Trade trade(amount, price, buyOrder, sellOrder);
tradeList.push_back(trade);
buyOrder.decreaseAmount(amount);
sellOrder.decreaseAmount(amount);
if (buyOrder.getAmount() == 0)
{
buyList.pop_front();
if (buyList.size() > 0)
buyOrder = buyList.front();
else
finished = true;
}
if (sellOrder.getAmount() == 0)
{
sellList.pop_front();
if (sellList.size() > 0)
sellOrder = sellList.front();
else
finished = true;
}
}
}
int main()
{
GOOGLE_PROTOBUF_VERIFY_VERSION;
Order order;
initOrder(&order);
// serialize object to string
std::string order_str;
order.SerializeToString(&order_str);
std::cout << order_str << std::endl;
std::string Order_debug = order.DebugString();
std::cout << Order_debug << std::endl;
Order order_2;
order_2.ParseFromString(order_str);
google::protobuf::ShutdownProtobufLibrary();
return 0;
}
void Position::HandleCommission( const Order& order ) {
//std::cout << "Position Comm: " << m_row.dblCommissionPaid << "," << order.GetCommission();
double dblNewCommissionPaid = order.GetIncrementalCommission();
//std::cout << "," << dblNewCommissionPaid << std::endl;
if ( 0 != dblNewCommissionPaid ) {
m_row.dblCommissionPaid += dblNewCommissionPaid;
OnUpdateCommissionForPortfolioManager( *this );
OnCommission( PositionDelta_delegate_t( *this, 0, dblNewCommissionPaid ) );
}
}
bool BidOrOffer::Load(PacketBase& packet)
{
m_lstOrders.clear();
if (!packet.ReadString(m_strBidPrice, 10))
return false;
int nOrderCount;
if (!packet.ReadInt(nOrderCount, 4))
return false;
while (--nOrderCount >= 0)
{
Order order;
if (!order.Load(packet))
return false;
m_lstOrders.push_back(order);
}
return true;
}
void GameTraceCollector::CollectGameTraceForBuildAddon(const Unit unit)
{
Order order = unit->getOrder();
ActionType action;
// PlaceAddon order has a special handling
_ASSERTE(unit->isBeingConstructed());
LogInfo("(P%d,%s) %s[%d]: %s",
unit->getPlayer()->getID(), unit->getPlayer()->getName().c_str(),
unit->getType().getName().c_str(), unit->getID(), order.c_str());
LogInfo("Order PlaceAddon for %s will be collected", unit->getType().getName().c_str());
_ASSERTE(g_Database.ActionMapping.ContainsFirst(Orders::PlaceAddon.getID()));
action = g_Database.ActionMapping.GetByFirst(Orders::PlaceAddon.getID());
PlanStepParameters actionParams = m_abstractor.GetAbstractedParameter(action, unit);
GameTrace *pTrace = new GameTrace(Broodwar->getFrameCount(), action, actionParams, g_Game->Snapshot(), m_playerToObserve);
SendGameTrace(pTrace);
}
void Orderbook::insertOrdertoAsk(Order order)
{
Message *insertMessage = new Message();
// look for order price set (key & vector) in the ask map
map<double, vector<Order>>::iterator orderInMap = Ask.find(order.getLimitPrice());
if (orderInMap == Ask.end()) // had not found
{
vector<Order> newVector;
newVector.push_back(order);
Ask.insert(pair <double, vector<Order>>(order.getLimitPrice(), newVector));
insertMessage->insertToNewMapPrice(order);
}
else // Map already has orders with same price
{
orderInMap->second.push_back(order);
insertMessage->insertToVector(order, (int)orderInMap->second.size());
}
delete insertMessage;
}
void Orderbook::insertOrdertoBid(Order order)
{
Message *insertMessage = new Message();
// look for order price set (key & vector) in the bid map
map<double, vector<Order>>::iterator orderInMap = Bid.find(order.getLimitPrice());
if (orderInMap == Bid.end()) // No existing price in map
{
vector<Order> newVector;
newVector.push_back(order);
Bid.insert(pair <double, vector<Order>>(order.getLimitPrice(), newVector));
insertMessage->insertToNewMapPrice(order);
}
else // Map already has orders with same price (put order in vector of orders (of the same price))
{
orderInMap->second.push_back(order);
insertMessage->insertToVector(order, (int)orderInMap->second.size());
}
// Garbage removal
delete insertMessage;
}
void DocumentZALController::insertOrderData(Order order)
{
view->getLineOrderSymbol()->setText(order.getSymbol());
view->setContractorData(order.getContractor());
view->setLineIssueName(order.getIssueName());
view->setLineReceiveName(order.getReceiveName());
view->setLineDiscount(order.getDiscount());
view->setLineDocumentPlace(order.getDocumentPlace());
manager->setContractor(order.getContractor());
manager->setDocumentPositions(order.getDocumentPositions());
manager->countGoodsValue(view->getDiscountOrWaybillNo()->text().toDouble());
setGoodsValue();
addGood();
}
void OrderBook::displayBids() //Function to display Bids
{
deque<Order*> x1;
Order* x = new Order();
if(BidBook.empty())
{
cout<<"There are no Bid Orders. The book is empty"<<endl<<endl<<endl;
return;
}
for(map<double,deque<Order*> >::iterator it=BidBook.begin(); it!=BidBook.end(); it++)
{
x1 = it->second; //Get Queue from that particular price and iterate over it
for (deque<Order*>::iterator it2 = x1.begin(); it2!=x1.end(); it2++)
{
x = *it2;
cout<<"Name: "<<x->getCounterParty()<<endl;
cout<<"Security: "<<x->getSecurity()<<endl;
cout<<"Type: "<<x->getType()<<endl;
cout<<"Quantity: "<<x->getQuantity()<<endl;
cout<<"Price: "<<x->getLimit()<<endl;
}
}
return;
}
void OrderBook::displayAsks() //Function to display Asks
{
deque<Order*> x1;
Order* x = new Order();
if(AskBook.empty())//if its empty there is a special message
{
cout<<"There are no Ask Orders."<<endl<<endl<<endl;
return;
}
//Using an iterator to run over the map and print out the corresponding object
for(map<double,deque<Order*> >::iterator it=AskBook.begin(); it!=AskBook.end(); it++)
{
x1 = it->second;
for (deque<Order*>::iterator it2 = x1.begin(); it2!=x1.end(); it2++)//run through entire deque and price elements
{
x = *it2;//store the order itself
cout<<"Name: "<<x->getCounterParty()<<endl;
cout<<"Security: "<<x->getSecurity()<<endl;
cout<<"Type: "<<x->getType()<<endl;
cout<<"Quantity: "<<x->getQuantity()<<endl;
cout<<"Price: "<<x->getLimit()<<endl;
}
}
return;
}
void CtpTradeSpi::ReqOrderInsert(Order ord){
SYNC_PRINT << ("Execute Order (") << ord.GetInstrumentId() << ", " \
<< ord.GetRefExchangePrice() << ", " \
<< (ord.GetExchangeDirection() == THOST_FTDC_D_Buy ? "Buy)" : "Sell)");
ord.SetIdentityInfo(m_brokerID, m_userID, m_userID, m_orderRef);
int nextOrderRef = atoi(m_orderRef);
SPRINTF(m_orderRef, "%d", ++nextOrderRef);
CThostFtdcInputOrderField ordstruct;
bool success = ord.GetOrderOriginStruct(ordstruct);
if (success){
SYNC_PRINT << "[Debug] 插入订单:" << CommonUtils::StringFromStruct(ordstruct);
int ret = pUserApi->ReqOrderInsert(&ordstruct, ++requestId);
SYNC_PRINT << "[Trade] 请求 | 插入订单..." << ((ret == 0) ? "成功" : "失败");
//if (ret)
// g_OrderRunMtx.unlock();
}
else{
SYNC_PRINT << "[Trade] Invalid OrderField construct";
}
}
double BrokerWithVolumeBasedCommission::calculate_commission(const Order & order) const
{
const int volume = order.volume();
if (volume <= 40)
{
return 0.03;
}
else if (volume <= 80)
{
return 0.025;
}
return 0.02;
}
int main()
{
map<int, string> menu;
menu[1] = "waffless";
menu[2] = "pancakes";
menu[3] = "pizza";
menu[4] = "fries";
menu[5] = "burger";
menu[6] = "cheeseburger";
menu[7] = "pie";
menu[8] = "cake";
menu[9] = "brownie";
menu[10] = "cookie";
Order ordering;
cout << "Welcome to 'The Rarest Pepe' What would you like to order today? (choose a #) \n" << endl;
for (auto const& m : menu) {
std::cout << m.first << ") " << m.second << '\n';
}
while(true) {
int food;
string size;
cin >> food;
if(food != 0)
{
cout << "What size? (s)mall, (m)edium or (l)arge?" << endl;
cin >> size;
ordering.orderA(nameToSize(size), menu[food]);
} else {
void Renderer::render(Order &order)
{
//Set background
for(int x = 0; x < width_; x++)
{
for(int y = 0; y < height_; y++)
{
int pos = x + (y * width_);
buffer_[pos] = colorBackground_.ABGR();
}
}
double width = width_ - marginLeft_ - marginRight_;
double height = height_ - marginTop_ - marginBottom_;
double ratio = width / height;
int w, h;
double wasted = grid::findBest(order.size(), ratio, w, h);
double contentRatio = double(w) / double(h);
double characterWidth = width / double(w);
double characterHeight = height / double(h);
int fontSize = contentRatio < ratio ? (int) characterHeight : (int) characterWidth;
FT_Select_Charmap(face_, ft_encoding_unicode);
FT_Set_Pixel_Sizes(face_, 0, fontSize);
for(int i = 0; i < order.size(); i++)
{
int gridX = (i % w) * characterWidth + marginLeft_;
int gridY = (i / w) * characterHeight + marginTop_;
renderGlyph(face_, order.kanji(i).character());
drawGlyph(buffer_, width_, gridX, gridY, face_->glyph, fontSize, SRSColor(order.kanji(i).SRS()));
}
}
TEST(Order, Construotor) {
const Order o(1, 1, 1, 1, 1, Date());
EXPECT_EQ(o.getOrderID(), 1);
EXPECT_EQ(o.getCustomerID(), 1);
EXPECT_EQ(o.getSKU(), 1);
EXPECT_EQ(o.getQuantity(), 1);
EXPECT_EQ(o.getPrice(), 1);
// EXPECT_EQ(o.getDate().serializeDate(), Date().serializeDate());
}
int main() {
// Instantiate order and queue
Order *order = new Order();
order->queue = newQueue();
// Get the file if possible
ifstream input;
get_file( input );
// Confirmation number must start at 1
order->confirmation_number = 1;
// Config current time
order->current_time.tm_hour = 0;
order->current_time.tm_min = 0;
order->current_time.tm_sec = 0;
// Config starting number of tickets used
order->num_tickets_used = 0;
// Set starting tick_time to compare with current time
order->tick_time = order->current_time;
// Continue to simulate processing the tickets until all tickets are processed
while( order->num_tickets_used != NUM_TICKETS_AVAILABLE &&
( !queue_empty(order->queue) || !input.eof() ) ) {
// Simulate getting orders
order->get_orders( input );
// Simulate processing the order
order->process_order();
}
// Delete dynamically allocated memory
delete order->queue;
delete order;
return 0;
}
//--------------------------------------------------------------------
// getKeyboardOrder
//--------------------------------------------------------------------
bool getKeyboardOrder(Order &order)
{
order.reset();
char rep;
read(0,&rep,1);
// printf("read=%d\n", rep);
switch (rep) {
// motor
case 27 :
read(0,&rep,1);
read(0,&rep,1);
switch (rep) {
case 'A' : handleForward(order); break;
case 'B' : handleBackward(order); break;
case 'D' : handleLeft(order); break;
case 'C' : handleRight(order); break;
}
break;
case '8' : handleForward(order); break;
case '2' : handleBackward(order); break;
case '4' : handleLeft(order); break;
case '6' : handleRight(order); break;
// emergency stop
case '5' :
case ' ' :
setEmergencyStopOrder(order);
break;
case 'r' :
case 'R' :
order.resetRobotPos=true;
order.motorReset=1;
order.speedLeft=0;
order.speedRight=0;
break;
case 'h' :
case 'H' :
showUsage();
break;
case 'q':
case 'Q':
case '-':
quitApplication = true;
break;
default:
break;
}
checkMotorOrder(order);
return true;
}
void Market::match( Order& bid, Order& ask )
{
double price = ask.getPrice();
long quantity = 0;
if ( bid.getOpenQuantity() > ask.getOpenQuantity() )
quantity = ask.getOpenQuantity();
else
quantity = bid.getOpenQuantity();
bid.execute( price, quantity );
ask.execute( price, quantity );
}
Order * Order::CreateOrder( int nOrderID,int nItemID, int nUserID, double fPriceOfEach, double fNumbers, QDate orderdate, QDate inputdate )
{
Order *order = new Order();
if (nMaxID < nOrderID)
{
nMaxID = nOrderID;
}
order->OrderID(nOrderID);
order->ItemID(nItemID);
order->UserID(nUserID);
order->PriceOfEach(fPriceOfEach);
order->Numbers(fNumbers);
order->OrderDate(orderdate);
order->InputDate(inputdate);
return order;
}
QList<Order*> AccountTradeInfo::GetOrders(QDate const& oTradeDay)
{
QMutexLocker oLocker(&m_mLock);
if(oTradeDay == m_pInstrument->GetTradeDay())
{
return m_lTradeDayOrders;
}
QList<Order*> lOrders;
if(!m_bOrderLoaded)
{
m_bOrderLoaded = true;
LoadOrders();
}
for(int nCount = 0 ; nCount < m_lOrders.size() ; nCount)
{
Order *pOrder = m_lOrders[nCount];
if(pOrder->GetTradeDay() == oTradeDay)
{
lOrders.append(pOrder);
}
}
return lOrders;
}
// Cancel an order
void Orders::cancel_order() {
int num_res_tickets;
// Check if there are any orders to cancel.
if (this->orders_list->is_empty()) {
cout << "\nThere are no registred orders.";
} else {
int ref_nr, row, col;
ref_nr = Tools::read_number("\nEnter your reference number", 2,
this->highest_order_nr(), Tools::numbers);
// Check if the order is in the list.
if (this->orders_list->in_list(ref_nr)) {
// Removes the object in the list with the ref nr
// Need to minus the refnr by one because we started the index at 2
Order* order = (Order*) this->orders_list->remove_no(ref_nr - 1);
// Checks if the tickets were picked up
if (!order->get_picked_up()) {
// Gets the screen object from the order
Screen* screen = order->get_screen();
// Loops through seats ordered and sets the value back to "1"
for (int i = 0; i < order->get_num_ordered_tickets(); ++i) {
// Gets the row out of the seatnr
row = int(order->get_seat_number(i) / 100);
// Gets the col out of the seatnr
col = order->get_seat_number(i) % 100;
// Sets the position to "1"
screen->get_auditorium_copy()->set_matrix_value(row, col, 1);
}
// Updates the number of orders
--this->num_orders;
// Updates the num reserved tickets (see the minus)
num_res_tickets = -order->get_num_ordered_tickets();
order->update_num_reserved_tickets(num_res_tickets);
// Writes the updates to file
this->write_to_file();
_screens->write_to_file();
cout << "\nThe order with reference number " << ref_nr
<< " was canceled.";
} else {
cout << "\nThe tickets were already picked up.";
this->orders_list->add(order);
}
} else {
cout << "\nThe entered reference number does not exist.";
}
}
}
// Collects tickets of an order
bool Orders::collect() {
int num_res_tickets, ref_nr;
// Check if there are any orders to collect.
if (this->orders_list->is_empty()) {
cout << "\nThere are no registred orders.";
return false;
}
ref_nr = Tools::read_number("\nEnter your reference number", 2,
this->highest_order_nr(), Tools::numbers);
// We need to minus the ref_nr by one because we started the index at 2
if (this->orders_list->in_list(ref_nr)) {
// Removes the object in the list with the ref nr
Order* order = (Order*) this->orders_list->remove_no(ref_nr - 1);
// Adds the order back to the list
this->orders_list->add(order);
// Checks if the tickets were picked up
if (!order->get_picked_up()) {
// Sets the tickets to picked up
order->set_picked_up(true);
// Prints out the tickets
order->print_tickets();
// Updates the num reserved tickets (see the minus)
num_res_tickets = -order->get_num_ordered_tickets();
order->update_num_reserved_tickets(num_res_tickets);
// Updates the num sold tickets
num_res_tickets = order->get_num_ordered_tickets();
order->update_num_sold_tickets(num_res_tickets);
// Prints out the matrix
order->get_screen()->print_matrix();
// Writes updates to file
this->write_to_file();
_screens->write_to_file();
} else {
cout << "\nThe tickets were already picked up.";
}
} else {
cout << "\nThe entered reference number does not exist.";
}
return true;
}
void Market::erase( const Order& order )
{
std::string id = order.getClientID();
if ( order.getSide() == Order::buy )
{
BidOrders::iterator i;
for ( i = m_bidOrders.begin(); i != m_bidOrders.end(); ++i )
if ( i->second.getClientID() == id )
{
m_bidOrders.erase( i );
return ;
}
}
else if ( order.getSide() == Order::sell )
{
AskOrders::iterator i;
for ( i = m_askOrders.begin(); i != m_askOrders.end(); ++i )
if ( i->second.getClientID() == id )
{
m_askOrders.erase( i );
return ;
}
}
}
void GameTraceCollector::CollectGameTraceForUnitOrder(const Unit unit)
{
Order order = unit->getOrder();
// Train order has a special handling
_ASSERTE(unit->getOrder() != Orders::Train);
_ASSERTE(unit->getOrder() != Orders::PlaceAddon);
ActionType action;
LogInfo("(P%d,%s) %s[%d]: %s",
unit->getPlayer()->getID(), unit->getPlayer()->getName().c_str(),
unit->getType().getName().c_str(), unit->getID(), order.c_str());
// We send traces only for actions recognized by the engine
if (!g_Database.ActionMapping.TryGetByFirst(order.getID(), action))
{
LogInfo("Order %s will not be collected, it is not supported order", order.c_str());
return;
}
else
{
LogInfo("Order %s will be collected", order.c_str());
}
GameTrace *pTrace = nullptr;
PlanStepParameters actionParams = m_abstractor.GetAbstractedParameter(action, unit);
pTrace = new GameTrace(Broodwar->getFrameCount(), action, actionParams, g_Game->Snapshot(), m_playerToObserve);
if (action == ACTIONEX_AttackEntity || action == ACTIONEX_AttackGround)
{
LogInfo("test");
}
SendGameTrace(pTrace);
}
