Add Temporal Backlash ...

.gitignore

@@ -0,0 +1,2 @@
+obj/**
+tu_optimize

Makefile

@@ -0,0 +1,18 @@
+MAIN := tuo.exe
+SRCS := $(wildcard *.cpp)
+OBJS := $(patsubst %.cpp,obj/%.o,$(SRCS))
+INCS := $(wildcard *.h)
+
+CPPFLAGS := -Wall -Werror -std=gnu++11 -O3 -DNDEBUG
+LDFLAGS := -lboost_system -lboost_thread -lboost_filesystem -lboost_regex
+
+all: $(MAIN)
+
+obj/%.o: %.cpp $(INCS)
+	$(CXX) $(CPPFLAGS) -o $@ -c $<
+
+$(MAIN): $(OBJS)
+	$(CXX) -o $@ $(OBJS) $(LDFLAGS)
+
+clean:
+	del /q $(MAIN).exe obj\*.o

Makefile-debug

@@ -0,0 +1,18 @@
+MAIN := tuodebug.exe
+SRCS := $(wildcard *.cpp)
+OBJS := $(patsubst %.cpp,obj-debug/%.o,$(SRCS))
+INCS := $(wildcard *.h)
+
+CPPFLAGS := -Wall -Werror -std=gnu++11 -O3
+LDFLAGS := -lboost_system -lboost_thread -lboost_filesystem -lboost_regex
+
+all: $(MAIN)
+
+obj-debug/%.o: %.cpp $(INCS)
+	$(CXX) $(CPPFLAGS) -o $@ -c $<
+
+$(MAIN): $(OBJS)
+	$(CXX) -o $@ $(OBJS) $(LDFLAGS)
+
+clean:
+	del /q $(MAIN).exe obj-debug\*.o

Makefile.osx

@@ -0,0 +1,18 @@
+MAIN := tuo
+SRCS := $(wildcard *.cpp)
+OBJS := $(patsubst %.cpp,obj/%.o,$(SRCS))
+INCS := $(wildcard *.h)
+
+CPPFLAGS := -Wall -Werror -std=c++11 -stdlib=libc++ -O3 -I/usr/local/include -Wno-deprecated-register -DNDEBUG
+LDFLAGS := lib/libboost_system-mt.a lib/libboost_thread-mt.a lib/libboost_filesystem-mt.a lib/libboost_regex-mt.a -L/usr/local/lib -Bstatic
+
+all: $(MAIN)
+
+obj/%.o: %.cpp ${INCS}
+	$(CXX) $(CPPFLAGS) -o $@ -c $<
+
+$(MAIN): $(OBJS)
+	$(CXX) -o $@ $(OBJS) $(LDFLAGS)
+
+clean:
+	rm -f $(MAIN) obj/*.o

card.h

@@ -0,0 +1,58 @@
+#ifndef CARD_H_INCLUDED
+#define CARD_H_INCLUDED
+
+#include <cstring>
+#include <string>
+#include <vector>
+#include "tyrant.h"
+
+class Card
+{
+public:
+    unsigned m_attack;
+    unsigned m_base_id;  // The id of the original card if a card is unique and alt/upgraded. The own id of the card otherwise.
+    unsigned m_delay;
+    Faction m_faction;
+    unsigned m_health;
+    unsigned m_id;
+    unsigned m_level;
+    unsigned m_fusion_level;
+    std::string m_name;
+    unsigned m_rarity;
+    unsigned m_set;
+    std::vector<SkillSpec> m_skills;
+    unsigned m_skill_value[num_skills];
+    CardType::CardType m_type;
+    const Card* m_top_level_card; // [TU] corresponding full-level card
+    unsigned m_recipe_cost;
+    std::map<const Card*, unsigned> m_recipe_cards;
+    std::map<const Card*, unsigned> m_used_for_cards;
+
+public:
+    Card() :
+        m_attack(0),
+        m_base_id(0),
+        m_delay(0),
+        m_faction(imperial),
+        m_health(0),
+        m_id(0),
+        m_level(1),
+        m_fusion_level(0),
+        m_name(""),
+        m_rarity(1),
+        m_set(0),
+        m_skills(),
+        m_type(CardType::assault),
+        m_top_level_card(this),
+        m_recipe_cost(0),
+        m_recipe_cards(),
+        m_used_for_cards()
+    {
+        std::memset(m_skill_value, 0, sizeof m_skill_value);
+    }
+
+    void add_skill(Skill id, unsigned x, Faction y, unsigned n, unsigned c, Skill s, Skill s2, bool all);
+    const Card* upgraded() const { return this == m_top_level_card ? this : m_used_for_cards.begin()->first; }
+};
+
+#endif

cards.cpp

@@ -0,0 +1,173 @@
+#include "cards.h"
+
+#include <boost/tokenizer.hpp>
+#include <sstream>
+#include <stdexcept>
+#include <cstring>
+#include <list>
+#include <iostream>
+
+#include "tyrant.h"
+#include "card.h"
+
+std::string simplify_name(const std::string& card_name)
+{
+    std::string simple_name;
+    for(auto c : card_name)
+    {
+        if(!strchr(";:,\"'! ", c))
+        {
+            simple_name += ::tolower(c);
+        }
+    }
+    return(simple_name);
+}
+
+std::list<std::string> get_abbreviations(const std::string& name)
+{
+    std::list<std::string> abbr_list;
+    boost::tokenizer<boost::char_delimiters_separator<char>> word_token{name, boost::char_delimiters_separator<char>{false, " -", ""}};
+    std::string initial;
+    auto token_iter = word_token.begin();
+    for(; token_iter != word_token.end(); ++token_iter)
+    {
+        abbr_list.push_back(simplify_name(std::string{token_iter->begin(), token_iter->end()}));
+        initial += *token_iter->begin();
+    }
+    abbr_list.push_back(simplify_name(initial));
+    return(abbr_list);
+}
+
+//------------------------------------------------------------------------------
+Cards::~Cards()
+{
+    for (Card* c: all_cards) { delete(c); }
+}
+
+const Card* Cards::by_id(unsigned id) const
+{
+    const auto cardIter = cards_by_id.find(id);
+    if(cardIter == cards_by_id.end())
+    {
+        throw std::runtime_error("No card with id " + to_string(id));
+    }
+    else
+    {
+        return(cardIter->second);
+    }
+}
+//------------------------------------------------------------------------------
+void Cards::organize()
+{
+    cards_by_id.clear();
+    player_cards.clear();
+    cards_by_name.clear();
+    player_commanders.clear();
+    player_assaults.clear();
+    player_structures.clear();
+    // Round 1: set cards_by_id
+    for(Card* card: all_cards)
+    {
+        cards_by_id[card->m_id] = card;
+    }
+    // Round 2: depend on cards_by_id / by_id(); update m_name, [TU] m_top_level_card etc.; set cards_by_name; 
+    for(Card* card: all_cards)
+    {
+        // Remove delimiters from card names
+        size_t pos;
+        while((pos = card->m_name.find_first_of(";:,")) != std::string::npos)
+        {
+            card->m_name.erase(pos, 1);
+        }
+        // set m_top_level_card for non base cards
+        card->m_top_level_card = by_id(card->m_base_id)->m_top_level_card;
+        // Cards available ("visible") to players have priority
+        std::string base_name = card->m_name;
+        if (card == card->m_top_level_card)
+        {
+            add_card(card, card->m_name + "-" + to_string(card->m_level));
+        }
+        else
+        {
+            card->m_name += "-" + to_string(card->m_level);
+        }
+        add_card(card, card->m_name);
+    }
+#if 0 // TODO refactor precedence
+    // Round 3: depend on cards_by_name; set abbreviations
+    for(Card* card: cards)
+    {
+        // generate abbreviations
+        if(card->m_set > 0)
+        {
+            for(auto&& abbr_name : get_abbreviations(card->m_name))
+            {
+                if(abbr_name.length() > 1 && cards_by_name.find(abbr_name) == cards_by_name.end())
+                {
+                    player_cards_abbr[abbr_name] = card->m_name;
+                }
+            }
+        }
+    }
+#endif
+}
+
+void Cards::add_card(Card * card, const std::string & name)
+{
+    std::string simple_name{simplify_name(name)};
+    auto card_itr = cards_by_name.find(simple_name);
+    signed old_visible = card_itr == cards_by_name.end() ? -1 : visible_cardset.count(card_itr->second->m_set);
+    signed new_visible = visible_cardset.count(card->m_set);
+    if (card_itr != cards_by_name.end())
+    {
+        if (old_visible == new_visible)
+        {
+            ambiguous_names.insert(simple_name);
+        }
+        _DEBUG_MSG(2, "Duplicated card name \"%s\" [%u] set=%u (visible=%u) : [%u] set=%u (visible=%u)\n", name.c_str(), card_itr->second->m_id, card_itr->second->m_set, old_visible, card->m_id, card->m_set, new_visible);
+    }
+    else if (old_visible < new_visible)
+    {
+        ambiguous_names.erase(simple_name);
+        cards_by_name[simple_name] = card;
+        if (new_visible)
+        {
+            player_cards.push_back(card);
+            switch(card->m_type)
+            {
+                case CardType::commander: {
+                    player_commanders.push_back(card);
+                    break;
+                }
+                case CardType::assault: {
+                    player_assaults.push_back(card);
+                    break;
+                }
+                case CardType::structure: {
+                    player_structures.push_back(card);
+                    break;
+                }
+                case CardType::num_cardtypes: {
+                    throw card->m_type;
+                    break;
+                }
+            }
+        }
+    }
+}
+
+// class Card
+void Card::add_skill(Skill id, unsigned x, Faction y, unsigned n, unsigned c, Skill s, Skill s2, bool all)
+{
+    for(auto it = m_skills.begin(); it != m_skills.end(); ++ it)
+    {
+        if(it->id == id)
+        {
+            m_skills.erase(it);
+            break;
+        }
+    }
+    m_skills.push_back({id, x, y, n, c, s, s2, all});
+    m_skill_value[id] = x ? x : n ? n : 1;
+}
+

cards.h

@@ -0,0 +1,33 @@
+#ifndef CARDS_H_INCLUDED
+#define CARDS_H_INCLUDED
+
+#include <map>
+#include <string>
+#include <unordered_set>
+#include <vector>
+
+class Card;
+
+class Cards
+{
+public:
+    ~Cards();
+
+    std::vector<Card*> all_cards;
+    std::map<unsigned, Card*> cards_by_id;
+    std::vector<Card*> player_cards;
+    std::map<std::string, Card*> cards_by_name;
+    std::vector<Card*> player_commanders;
+    std::vector<Card*> player_assaults;
+    std::vector<Card*> player_structures;
+    std::map<std::string, std::string> player_cards_abbr;
+    std::unordered_set<unsigned> visible_cardset;
+    std::unordered_set<std::string> ambiguous_names;
+    const Card * by_id(unsigned id) const;
+    void organize();
+    void add_card(Card * card, const std::string & name);
+};
+
+std::string simplify_name(const std::string& card_name);
+
+#endif