lyrgb/exc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

updated naming

Browse Source
This commit is contained in:
my name
2026-07-17 12:06:22 +02:00
parent 8ff0e89bb1
commit ccd216591a
5 changed files with 80 additions and 94 deletions
Download Patch File Download Diff File Expand all files Collapse all files
cpp/ui/ncurses/hw/hwcurses.cpp
+19 -19
View File
@@ -19,24 +19,24 @@
centralize into event sender and subscriber
*/
void myupdatedisplay(const timer &timer_input) {
void myupdatedisplay(const Timer &timer_input) {
int x_offset = COLS / 4;
mvprintw(timer_input.triggercounter, timer_input.triggercounter + x_offset,
mvprintw(timer_input.trigger_counter, timer_input.trigger_counter + x_offset,
"test: █");
}
std::vector<int> mynumbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
std::vector<int> myothernumbers = {4, 9, 8, 6, 2, 1, 10, 3, 5, 7};
std::vector<int> my_numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
std::vector<int> my_other_numbers = {4, 9, 8, 6, 2, 1, 10, 3, 5, 7};
void displaynumbers(int startx, int starty, std::vector<int> &input_numbers, cchar_t &input_char) {
void displaynumbers(int start_x, int start_y, std::vector<int> &input_numbers, cchar_t &input_char) {
for (size_t i = 0; i < input_numbers.size(); i++) {
/**
I make a horizontal line of i chars, which are supposed to represent mynumbers
above that, I want a line of bars.
_all_ bars stretch from LINES-1 to LINES-1-numbervalue
**/
mvprintw(LINES -1 - starty, i + startx, "%d,", input_numbers[i]);
mvwvline_set(stdscr, LINES-1-input_numbers[i]-starty, i+startx, &input_char, input_numbers[i]);
mvprintw(LINES -1 - start_y, i + start_x, "%d,", input_numbers[i]);
mvwvline_set(stdscr, LINES-1-input_numbers[i]-start_y, i+start_x, &input_char, input_numbers[i]);
}
}
@@ -59,25 +59,25 @@ int main() {
//create actions, then put them in timers, then put them into the timermanager
auto myaction = std::make_unique<swapaction>(mynumbers);
auto clocktimer =
std::make_unique<timer>("secondsprinter", 1, 10, std::move(myaction));
auto my_action = std::make_unique<SwapAction>(my_numbers);
auto clock_timer =
std::make_unique<Timer>("secondsprinter", 1, 10, std::move(my_action));
auto myothersort = std::make_unique<sortaction>(myothernumbers);
auto sorttimer =
std::make_unique<timer>("sorttimer", 0.5, std::move(myothersort));
auto my_other_sort = std::make_unique<SortAction>(my_other_numbers);
auto sort_timer =
std::make_unique<Timer>("sorttimer", 0.5, std::move(my_other_sort));
timermanager mytimermanager;
mytimermanager.addtimer(std::move(clocktimer));
mytimermanager.addtimer(std::move(sorttimer));
TimerManager my_timer_manager;
my_timer_manager.addtimer(std::move(clock_timer));
my_timer_manager.addtimer(std::move(sort_timer));
while (true) {
erase();
mytimermanager.updatetimers();
my_timer_manager.updatetimers();
displaynumbers(0,0,mynumbers, my_c_char);
displaynumbers(10, 10, myothernumbers, my_c_char);
displaynumbers(0,0,my_numbers, my_c_char);
displaynumbers(10, 10, my_other_numbers, my_c_char);
refresh();
std::this_thread::sleep_for(std::chrono::milliseconds(50));
cpp/ui/ncurses/hw/timer.cpp
+15 -16
View File
@@ -2,47 +2,46 @@
#include "timer.hpp"
#include <algorithm>
#include <chrono>
#include <cstddef>
#include <memory>
#include <ncurses.h>
#include <string>
#include <vector>
// infinite timer
timer::timer(std::string name_input, double interval_input,
std::unique_ptr<timeraction> action_input)
Timer::Timer(std::string name_input, double interval_input,
std::unique_ptr<TimerAction> action_input)
: time_interval(interval_input), name(name_input), is_infinite(true),
action(std::move(action_input)) {}
// limited timer
timer::timer(std::string name, double interval_input, int triggeramount,
std::unique_ptr<timeraction> action_input)
: triggeramount(triggeramount), time_interval(interval_input), name(name),
Timer::Timer(std::string name, double interval_input, int trigger_amount,
std::unique_ptr<TimerAction> action_input)
: trigger_amount(trigger_amount), time_interval(interval_input), name(name),
action(std::move(action_input)) {}
// callbackfunc once enough time has accumulated
void timer::updatetime(double DeltaTime) {
accumulator += DeltaTime;
void Timer::updatetime(double delta_time) {
accumulator += delta_time;
if (!is_expired) {
if (accumulator >= time_interval) {
action->update(*this);
accumulator -= time_interval;
triggercounter++;
if (!is_infinite && triggercounter >= triggeramount) {
trigger_counter++;
if (!is_infinite && trigger_counter >= trigger_amount) {
is_expired = true;
}
}
}
}
void timermanager::addtimer(std::unique_ptr<timer> input_timer) {
void TimerManager::addtimer(std::unique_ptr<Timer> input_timer) {
timers.push_back(std::move(input_timer));
}
void timermanager::updatetimers() {
void TimerManager::updatetimers() {
//get dtime
auto currenttime = std::chrono::steady_clock::now();
std::chrono::duration<double> myDeltaTime = currenttime - prevtime;
auto current_time = std::chrono::steady_clock::now();
std::chrono::duration<double> myDeltaTime = current_time - prev_time;
double dtime = myDeltaTime.count();
//update timers with dtime
@@ -51,7 +50,7 @@ void timermanager::updatetimers() {
mvprintw(12, 0, "updated timer %s", mytimer->name.c_str());
}
//reset for next tick
prevtime = currenttime;
prev_time = current_time;
timers.erase(std::remove_if(timers.begin(), timers.end(),
[](auto &timer) { return timer->is_expired; }),
timers.end());
@@ -59,5 +58,5 @@ void timermanager::updatetimers() {
refresh();
}
timermanager::timermanager(): prevtime(std::chrono::steady_clock::now()){}
TimerManager::TimerManager(): prev_time(std::chrono::steady_clock::now()){}
cpp/ui/ncurses/hw/timer.hpp
+18 -27
View File
@@ -2,63 +2,54 @@
#define TIMER_HPP
#include <chrono>
#include <cstddef>
#include <functional>
#include <memory>
#include <ncurses.h>
#include <string>
#include <vector>
class timer;
class Timer;
struct balkjes {
int startx;
int starty;
int yhight;
};
class timeraction {
class TimerAction {
public:
virtual ~timeraction() = default;
virtual void update(const timer &t) = 0;
virtual ~TimerAction() = default;
virtual void update(const Timer &t) = 0;
};
class timer {
class Timer {
private:
double accumulator = 0;
int triggeramount = 0;
int trigger_amount = 0;
double time_interval = 1; // only display every 1 seconds
public:
std::string name;
int triggercounter = 0;
int trigger_counter = 0;
bool is_infinite = false;
std::unique_ptr<timeraction> action;
std::unique_ptr<TimerAction> action;
bool is_expired = false;
//infinite timer
timer(std::string name_input, double interval_input,
std::unique_ptr<timeraction> action_input
Timer(std::string name_input, double interval_input,
std::unique_ptr<TimerAction> action_input
);
//limited timer
timer(std::string name, double interval_input, int triggeramount,
std::unique_ptr<timeraction> action
Timer(std::string name, double interval_input, int trigger_amount,
std::unique_ptr<TimerAction> action
);
// callbackfunc once enough time has accumulated
void updatetime(double DeltaTime);
void updatetime(double delta_time);
};
// manage collection of timers
class timermanager {
std::vector<std::unique_ptr<timer>> timers;
std::chrono::steady_clock::time_point prevtime; // initial starttime
class TimerManager {
std::vector<std::unique_ptr<Timer>> timers;
std::chrono::steady_clock::time_point prev_time; // initial starttime
public:
timermanager();
void addtimer(std::unique_ptr<timer> input_timer);
TimerManager();
void addtimer(std::unique_ptr<Timer> input_timer);
void updatetimers();
};
cpp/ui/ncurses/hw/timeractions.cpp
+8 -12
View File
@@ -2,31 +2,27 @@
#include "timer.hpp"
#include "timeractions.hpp"
#include <algorithm>
#include <chrono>
#include <cstddef>
#include <memory>
#include <ncurses.h>
#include <string>
#include <vector>
swapaction::swapaction(std::vector<int> &input_vector): input_vector(input_vector){}
SwapAction::SwapAction(std::vector<int> &input_vector): input_vector(input_vector){}
void swapaction::update(const timer &input_timer){
if (!iscomplete) {
void SwapAction::update(const Timer &input_timer){
if (!is_complete) {
int temp = input_vector[it_i];
input_vector[it_i] = input_vector[input_vector.size() -1 - it_i];
input_vector[input_vector.size() - 1 - it_i] = temp;
it_i++;
if(it_i>=input_vector.size() / 2){iscomplete=true;}
if(it_i>=input_vector.size() / 2){is_complete=true;}
}
}
sortaction::sortaction(std::vector<int> &input_vector): input_vector(input_vector) {}
SortAction::SortAction(std::vector<int> &input_vector): input_vector(input_vector) {}
//sorts the included array using bsort and external iterators rather than for loops
void sortaction::update(const timer &input_timer) {
if (!iscomplete) {
void SortAction::update(const Timer &input_timer) {
if (!is_complete) {
/**
we take a number, it_i loop
compare it with its neighbour, it_j loop
@@ -47,7 +43,7 @@ void sortaction::update(const timer &input_timer) {
it_i++;
}
if (it_i>=input_vector.size()) {
iscomplete=true;
is_complete=true;
}
}
}
cpp/ui/ncurses/hw/timeractions.hpp
+8 -8
View File
@@ -10,23 +10,23 @@
#include <string>
#include <vector>
class swapaction : public timeraction {
class SwapAction : public TimerAction {
public:
size_t it_i = 0;
bool iscomplete = false;
bool is_complete = false;
std::vector<int> &input_vector;
swapaction(std::vector<int> &input_vector);
void update(const timer &t);
SwapAction(std::vector<int> &input_vector);
void update(const Timer &t);
};
class sortaction : public timeraction {
class SortAction : public TimerAction {
public:
size_t it_i = 0;
size_t it_j = 0;
bool iscomplete = false;
bool is_complete = false;
std::vector<int> &input_vector;
sortaction(std::vector<int> &input_vector);
void update(const timer &t);
SortAction(std::vector<int> &input_vector);
void update(const Timer &t);
};
#endif