src/core/controllerframe.cpp

   1 #include "cmdhelp/macro.hpp"
   2 #include "core/controllerframe.hpp"
   3 #include "core/controller.hpp"
   4 #include "core/dispatch.hpp"
   5 #include "core/messages.hpp"
   6 #include "core/moviedata.hpp"
   7 #include "core/project.hpp"
   8 #include "interface/romtype.hpp"
   9
  10 #include <cstdio>
  11 #include <iostream>
  12
  13 namespace
  14 {
  15         portctrl::type_set dummytypes;
  16 }
  17
  18 controller_state::controller_state(project_state& _project, movie_logic& _mlogic, button_mapping& _buttons,
  19         emulator_dispatch& _dispatch, status_updater& _supdater, command::group& _cmd) throw()
  20         : project(_project), mlogic(_mlogic), buttons(_buttons), edispatch(_dispatch), supdater(_supdater),
  21         cmd(_cmd),
  22         macro_p(cmd, STUBS::macrop, [this](const std::string& a) { this->do_macro(a, 5); }),
  23         macro_r(cmd, STUBS::macror, [this](const std::string& a) { this->do_macro(a, 2); }),
  24         macro_t(cmd, STUBS::macrot, [this](const std::string& a) { this->do_macro(a, 7); })
  25 {
  26         types = &dummytypes;
  27         tasinput_enaged = false;
  28 }
  29
  30 std::pair<int,int> controller_state::lcid_to_pcid(unsigned lcid) throw()
  31 {
  32         if(lcid >= types->number_of_controllers())
  33                 return std::make_pair(-1, -1);
  34         auto k = types->lcid_to_pcid(lcid);
  35         return std::make_pair(k.first, k.second);
  36 }
  37
  38 std::pair<int, int> controller_state::legacy_pcid_to_pair(unsigned pcid) throw()
  39 {
  40         if(pcid >= types->number_of_legacy_pcids())
  41                 return std::make_pair(-1, -1);
  42         auto k = types->legacy_pcid_to_pair(pcid);
  43         return std::make_pair(k.first, k.second);
  44 }
  45
  46
  47 portctrl::frame controller_state::get(uint64_t framenum) throw()
  48 {
  49         portctrl::frame tmp =  _input ^ _framehold ^ _autohold;
  50         for(auto i : _autofire)
  51                 if(i.second.eval_at(framenum))
  52                         tmp.axis2(i.first, tmp.axis2(i.first) ^ 1);
  53         if(tasinput_enaged)
  54                 for(auto i : _tasinput) {
  55                         if(i.second.mode == 0 && i.second.state)
  56                                 tmp.axis2(i.first, tmp.axis2(i.first) ^ 1);
  57                         else if(i.second.mode == 1)
  58                                 tmp.axis2(i.first, i.second.state);
  59                 }
  60         apply_macro(tmp);
  61         return tmp;
  62 }
  63
  64 void controller_state::analog(unsigned port, unsigned controller, unsigned control, short x) throw()
  65 {
  66         _input.axis3(port, controller, control, x);
  67 }
  68
  69 void controller_state::autohold2(unsigned port, unsigned controller, unsigned pbid, bool newstate) throw()
  70 {
  71         _autohold.axis3(port, controller, pbid, newstate ? 1 : 0);
  72         edispatch.autohold_update(port, controller, pbid, newstate);
  73 }
  74
  75 bool controller_state::autohold2(unsigned port, unsigned controller, unsigned pbid) throw()
  76 {
  77         return (_autohold.axis3(port, controller, pbid) != 0);
  78 }
  79
  80 void controller_state::autofire2(unsigned port, unsigned controller, unsigned pbid, unsigned duty, unsigned cyclelen)
  81         throw()
  82 {
  83         unsigned idx = _input.porttypes().triple_to_index(port, controller, pbid);
  84         if(duty) {
  85                 _autofire[idx].first_frame = mlogic.get_movie().get_current_frame();
  86                 _autofire[idx].duty = duty;
  87                 _autofire[idx].cyclelen = cyclelen;
  88         } else
  89                 _autofire.erase(idx);
  90 }
  91
  92 std::pair<unsigned, unsigned> controller_state::autofire2(unsigned port, unsigned controller, unsigned pbid) throw()
  93 {
  94         unsigned idx = _input.porttypes().triple_to_index(port, controller, pbid);
  95         if(!_autofire.count(idx))
  96                 return std::make_pair(0, 1);
  97         else
  98                 return std::make_pair(_autofire[idx].duty, _autofire[idx].cyclelen);
  99 }
 100
 101 bool controller_state::autofire_info::eval_at(uint64_t frame)
 102 {
 103         if(frame < first_frame) {
 104                 uint64_t diff = first_frame - frame;
 105                 frame += ((diff / cyclelen) + 1) * cyclelen;
 106         }
 107         return frame % cyclelen < duty;
 108 }
 109
 110 void controller_state::reset_framehold() throw()
 111 {
 112         _framehold = _framehold.blank_frame();
 113 }
 114
 115 void controller_state::framehold2(unsigned port, unsigned controller, unsigned pbid, bool newstate) throw()
 116 {
 117         _framehold.axis3(port, controller, pbid, newstate ? 1 : 0);
 118 }
 119
 120 bool controller_state::framehold2(unsigned port, unsigned controller, unsigned pbid) throw()
 121 {
 122         return (_framehold.axis3(port, controller, pbid) != 0);
 123 }
 124
 125 void controller_state::button2(unsigned port, unsigned controller, unsigned pbid, bool newstate) throw()
 126 {
 127         _input.axis3(port, controller, pbid, newstate ? 1 : 0);
 128 }
 129
 130 bool controller_state::button2(unsigned port, unsigned controller, unsigned pbid) throw()
 131 {
 132         return (_input.axis3(port, controller, pbid) != 0);
 133 }
 134
 135 void controller_state::tasinput(unsigned port, unsigned controller, unsigned pbid, int16_t state) throw()
 136 {
 137         unsigned idx = _input.porttypes().triple_to_index(port, controller, pbid);
 138         if(!_tasinput.count(idx))
 139                 _tasinput[idx].mode = 0;        //Just to be sure.
 140         _tasinput[idx].state = state;
 141 }
 142
 143 int16_t controller_state::tasinput(unsigned port, unsigned controller, unsigned pbid) throw()
 144 {
 145         unsigned idx = _input.porttypes().triple_to_index(port, controller, pbid);
 146         return  _tasinput.count(idx) ? _tasinput[idx].state : 0;
 147 }
 148
 149 void controller_state::tasinput_enable(bool enabled)
 150 {
 151         tasinput_enaged = enabled;
 152 }
 153
 154 void controller_state::reread_tasinput_mode(const portctrl::type_set& ptype)
 155 {
 156         unsigned indices = ptype.indices();
 157         _tasinput.clear();
 158         for(unsigned i = 0; i < indices; i++) {
 159                 auto t = ptype.index_to_triple(i);
 160                 if(!t.valid)
 161                         continue;
 162                 //See what the heck that is...
 163                 const portctrl::type& pt = ptype.port_type(t.port);
 164                 const portctrl::controller_set& pci = *(pt.controller_info);
 165                 if(pci.controllers.size() <= t.controller)
 166                         continue;
 167                 const portctrl::controller& pc = pci.controllers[t.controller];
 168                 if(pc.buttons.size() <= t.control)
 169                         continue;
 170                 const portctrl::button& pcb = pc.buttons[t.control];
 171                 if(pcb.shadow)
 172                         continue;
 173                 if(pcb.type == portctrl::button::TYPE_BUTTON)
 174                         _tasinput[i].mode = 0;
 175                 else
 176                         _tasinput[i].mode = 1;
 177                 _tasinput[i].state = 0;
 178         }
 179 }
 180
 181 void controller_state::set_ports(const portctrl::type_set& ptype) throw(std::runtime_error)
 182 {
 183         const portctrl::type_set* oldtype = types;
 184         types = &ptype;
 185         if(oldtype != types) {
 186                 _input.set_types(ptype);
 187                 _autohold.set_types(ptype);
 188                 _committed.set_types(ptype);
 189                 _framehold.set_types(ptype);
 190                 //The old autofire pattern no longer applies.
 191                 _autofire.clear();
 192                 reread_tasinput_mode(ptype);
 193                 _autohold = _autohold.blank_frame();
 194                 buttons.reread();
 195                 edispatch.autohold_reconfigure();
 196         }
 197 }
 198
 199 portctrl::frame controller_state::get_blank() throw()
 200 {
 201         return _input.blank_frame();
 202 }
 203
 204 portctrl::frame controller_state::get_committed() throw()
 205 {
 206         return _committed;
 207 }
 208
 209 void controller_state::commit(portctrl::frame controls) throw()
 210 {
 211         _committed = controls;
 212 }
 213
 214 bool controller_state::is_present(unsigned port, unsigned controller) throw()
 215 {
 216         return _input.is_present(port, controller);
 217 }
 218
 219 void controller_state::erase_macro(const std::string& macro)
 220 {
 221         {
 222                 threads::alock h(macro_lock);
 223                 if(!all_macros.count(macro))
 224                         return;
 225                 auto m = &all_macros[macro];
 226                 for(auto i = active_macros.begin(); i != active_macros.end(); i++) {
 227                         if(i->second == m) {
 228                                 active_macros.erase(i);
 229                                 break;
 230                         }
 231                 }
 232                 all_macros.erase(macro);
 233                 project_info* p = project.get();
 234                 if(p) {
 235                         p->macros.erase(macro);
 236                         p->flush();
 237                 }
 238         }
 239         buttons.load(*this);
 240 }
 241
 242 std::set<std::string> controller_state::enumerate_macro()
 243 {
 244         threads::alock h(macro_lock);
 245         std::set<std::string> r;
 246         for(auto i : all_macros)
 247                 r.insert(i.first);
 248         return r;
 249 }
 250
 251 portctrl::macro& controller_state::get_macro(const std::string& macro)
 252 {
 253         threads::alock h(macro_lock);
 254         if(!all_macros.count(macro))
 255                 throw std::runtime_error("No such macro");
 256         return all_macros[macro];
 257 }
 258
 259 void controller_state::set_macro(const std::string& macro, const portctrl::macro& m)
 260 {
 261         {
 262                 threads::alock h(macro_lock);
 263                 portctrl::macro* old = NULL;
 264                 if(all_macros.count(macro))
 265                         old = &all_macros[macro];
 266                 all_macros[macro] = m;
 267                 for(auto i = active_macros.begin(); i != active_macros.end(); i++) {
 268                         if(i->second == old) {
 269                                 i->second = &all_macros[macro];
 270                                 break;
 271                         }
 272                 }
 273                 project_info* p = project.get();
 274                 if(p) {
 275                         p->macros[macro] = all_macros[macro].serialize();
 276                         p->flush();
 277                 }
 278         }
 279         buttons.load(*this);
 280 }
 281
 282 void controller_state::apply_macro(portctrl::frame& f)
 283 {
 284         threads::alock h(macro_lock);
 285         for(auto i : active_macros)
 286                 i.second->write(f, i.first);
 287 }
 288
 289 void controller_state::advance_macros()
 290 {
 291         threads::alock h(macro_lock);
 292         for(auto& i : active_macros)
 293                 i.first++;
 294 }
 295
 296 std::map<std::string, uint64_t> controller_state::get_macro_frames()
 297 {
 298         threads::alock h(macro_lock);
 299         std::map<std::string, uint64_t> r;
 300         for(auto i : active_macros) {
 301                 for(auto& j : all_macros)
 302                         if(i.second == &j.second) {
 303                                 r[j.first] = i.first;
 304                         }
 305         }
 306         return r;
 307 }
 308
 309 void controller_state::set_macro_frames(const std::map<std::string, uint64_t>& f)
 310 {
 311         threads::alock h(macro_lock);
 312         std::list<std::pair<uint64_t, portctrl::macro*>> new_active_macros;
 313         for(auto i : f)
 314                 if(all_macros.count(i.first))
 315                         new_active_macros.push_back(std::make_pair(i.second, &all_macros[i.first]));
 316                 else
 317                         messages << "Warning: Can't find defintion for '" << i.first << "'" << std::endl;
 318         std::swap(active_macros, new_active_macros);
 319 }
 320
 321 void controller_state::rename_macro(const std::string& old, const std::string& newn)
 322 {
 323         {
 324                 threads::alock h(macro_lock);
 325                 if(!all_macros.count(old))
 326                         throw std::runtime_error("Old macro doesn't exist");
 327                 if(all_macros.count(newn))
 328                         throw std::runtime_error("Target name already exists");
 329                 if(old == newn)
 330                         return;
 331                 all_macros[newn] = all_macros[old];
 332                 portctrl::macro* _old = &all_macros[old];
 333                 all_macros.erase(old);
 334                 for(auto i = active_macros.begin(); i != active_macros.end(); i++) {
 335                         if(i->second == _old) {
 336                                 i->second = &all_macros[newn];
 337                                 break;
 338                         }
 339                 }
 340                 project_info* p = project.get();
 341                 if(p) {
 342                         p->macros[newn] = p->macros[old];
 343                         p->macros.erase(old);
 344                 }
 345         }
 346         buttons.load(*this);
 347 }
 348
 349 void controller_state::do_macro(const std::string& a, int mode) {
 350         {
 351                 threads::alock h(macro_lock);
 352                 if(!all_macros.count(a)) {
 353                         if(mode & 1) messages << "No such macro '" << a << "'" << std::endl;
 354                         return;
 355                 }
 356                 portctrl::macro* m = &all_macros[a];
 357                 for(auto i = active_macros.begin(); i != active_macros.end(); i++) {
 358                         if(i->second == m) {
 359                                 if(mode & 2) active_macros.erase(i);
 360                                 goto end;
 361                         }
 362                 }
 363                 if(mode & 4) active_macros.push_back(std::make_pair(0, m));
 364         }
 365 end:
 366         supdater.update();
 367         edispatch.status_update();
 368 }
 369
 370 std::set<std::string> controller_state::active_macro_set()
 371 {
 372         threads::alock h(macro_lock);
 373         std::set<std::string> r;
 374         for(auto i : active_macros) {
 375                 for(auto& j : all_macros)
 376                         if(i.second == &j.second) {
 377                                 r.insert(j.first);
 378                         }
 379         }
 380         return r;
 381 }