逐进变量

ancientcc

代码中处理逐进变量
让深入程序，分析代码是如何处理逐进变量。处理逐进变量主要是两个操作，赋值和取值。程序用template <class T> class progressive_类封装逐进变量。简单的说，赋值就是根据一条mod中的逐进变量语句生成一个progressive_对象，取值就是借助当前时刻参数，从progressive_对象读出变量值。
（<class T> class progressive_类，当中模板参数T可取int，double，int的就typedef为progressive_int，double的就typedef为progressive_double。以上halo_y就以progressive_int类型被处理，offset则是progressive_double。）

赋值
根据一条mod中的逐进变量语句生成一个progressive_对象。让以duration=350; halo_y=-54:120,-54~-45,-45~-27,-27~0为例来说明。

1. // @data: mod中的逐进变量字符串。实例值：-54:120,-54~-45,-45~-27,-27~0
   
2. // @duration: 持续时间，单位毫秒。实例值：350
   
3. template <class T>
   
4. progressive_<T>::progressive_(const std::string &data, int duration) :
   
5.         data_(),
   
6.         input_(data)
   
7. {
   
8.         // utils::split将以逗号为分隔符把字符串data变成字组串数组
   
9.         const std::vector<std::string> first_split = utils::split(data);
   
10.         // 生成的first_split：[4]("-54:120", "-54~-45","-45~-27","-27~0")
    
11.         const int time_chunk = std::max<int>(duration / (first_split.size()?first_split.size():1),1);
    
12.         // time_chunk就是默认的时间片持续时间：350 / 4 = 87（毫秒）
    
13. 
    
14.         std::vector<std::string>::const_iterator tmp;
    
15.         std::vector<std::pair<std::string,int> > first_pass;
    
16.         // 逐个处理值项
    
17.         for (tmp = first_split.begin(); tmp != first_split.end() ; tmp++) {
    
18.                 std::vector<std::string> second_pass = utils::split(*tmp,':');
    
19.                 if (second_pass.size() > 1) {
    
20.                         // 值项中指定了时间，则把时间取出来作为该时间片时间然后生成pair
    
21.                         first_pass.push_back(std::pair<std::string,int>(second_pass[0],atoi(second_pass[1].c_str())));
    
22.                 } else {
    
23.                         // 值项中没指定时间，以默认时间片生成pair
    
24.                         first_pass.push_back(std::pair<std::string,int>(second_pass[0],time_chunk));
    
25.                 }
    
26.         }
    
27.         // 生成的first_pass值：
    
28.         //                [0]        ("-54",120)
    
29.         //                [1]        ("-54~-45",87)
    
30.         //                [2]        ("-45~-27",87)
    
31.         //                [3]        ("-27~0",87)
    
32.     // 因为#0值项由87改为了120，这个总的过程时间已由350变成381
    
33.         std::vector<std::pair<std::string,int> >::const_iterator tmp2;
    
34.         // 逐个处理修正过时间片时间的值项
    
35.         for (tmp2=first_pass.begin();tmp2 != first_pass.end() ; tmp2++) {
    
36.                 std::vector<std::string> range = utils::split(tmp2->first,'~');
    
37.                 // 检查值项字符串是否有波浪号。
    
38.                 // 1. 如果有波浪号，波浪号前的做为pair的first，后面的做为pair的second
    
39.                 // 2. 如果没有波浪号，pair的second=first
    
40.                 data_.push_back(std::pair<std::pair<T, T>,int> (
    
41.                         std::pair<T, T>(
    
42.                                 lexical_cast<T>(range[0].c_str()),
    
43.                                 lexical_cast<T>(range.size() > 1 ? range[1].c_str() : range[0].c_str())),
    
44.                                 tmp2->second));
    
45.         }
    
46.         // 最终生成的data_：
    
47.         //                [0]        ((-54,-54),120)
    
48.         //                [1]        ((-54,-45),87)
    
49.         //                [2]        ((-45,-27),87)
    
50.         //                [3]        ((-27,0),87)
    
51. }

复制代码

取值
取值就是根据访问时刻返回“正确”值项中的值。
以在130毫秒来取值为例来说明。

1. // @current_time：当前访问时刻。值可以不在[0, duration]，函数会执行修正。实例值：130
   
2. // @default_val：当mod中其实未指定要访问的逐进变量时，要被返回的值。默认0
   
3. template <class T>
   
4. const T progressive_<T>::get_current_element(int current_time, T default_val) const
   
5. {
   
6.         int time = 0;
   
7.         unsigned int sub_halo = 0;
   
8.         int searched_time = current_time;
   
9.         // 检查current_time有效性，不在[0, duration()]的务必使它落在这范围
   
10.         // duration()返回data_中时间片时间的累加值，也就是说返回的将是381而不是mod中写的350
    
11.         if (searched_time < 0) searched_time = 0;
    
12.         if (searched_time > duration()) searched_time = duration();
    
13.         // 这或许是mod中就没有该逐进变量，返回默认值。
    
14.         if (data_.empty()) return default_val;
    
15.         // 找出current_time是落在哪个时间片上
    
16.         while (time < searched_time&& sub_halo < data_.size()) {
    
17.                 time += data_[sub_halo].second;
    
18.                 sub_halo++;
    
19. 
    
20.         }
    
21.         // (sub_halo!=0)时，sub_halo是一个计数值而不是索引值，作为下标时应该被修正
    
22.         if (sub_halo != 0) {
    
23.                 sub_halo--;
    
24.                 time -= data_[sub_halo].second;
    
25.         }
    
26.         if (sub_halo >= data_.size()) {
    
27.                 sub_halo = data_.size();
    
28.                 time = searched_time; // Never more than max allowed
    
29.         }
    
30. 
    
31.         // 已确定出current_time是在#1区间，现在要确定出具体值
    
32.         const T first =  data_[sub_halo].first.first;
    
33.         const T second =  data_[sub_halo].first.second;
    
34. 
    
35.         // time = data_[0].second: 120
    
36.         // data_[1].second: 87
    
37.         // first = data_[1].first.first: -54
    
38.         // second = data_[1].first.second: -45
    
39.         // ====>
    
40.         // (130 - 120) / 87 * 9 + (-54) = -53
    
41. 
    
42.         return T((static_cast<double>(searched_time - time) /
    
43.                 static_cast<double>(data_[sub_halo].second)) *
    
44.                 (second - first) + first);       
    
45. }

复制代码

代码中封装逐进变量还有一个类：progressive_string，和progressive_差不多赋值/取值逻辑。它们不同点：

• progressive_是模板类，progressive_string不是；
• progressive_值项中的first要表示一个范围，定义了std::pair，progressive_string表示一个字符串，类型std::string；
  

由于progressive_string的data_[#].first不是范围，它处理上要比progressive_简单。