Studio preliminare

take II
Intro

Sulla base dei risultati dello studio pilota dello studio preliminare, abbiamo deciso di portare aventi lo studio e quindi di sviluppare altre nuove matrici.
Per il momento, abbiamo deciso di:
eliminare la somministrazione delle Raven “originali” (studio per il futuro)
Considerare 3 matrici logiche e 3 matrici visuo spaziali
Abbiamo dei dubbi circa il tipo di disegno che vogliamo implementare. Nello specifico, non sappiamo se mantenere un disegno within o spostarci su un disegno between, dove il fattore between è il numero di distrattori.
Qui trovate la skill map usata per generare gli stimoli che seguono.
Qui trovate i risultati dello studio preliminare (Rasch).
Di seguito riportiamo le coppie equivalenti di matrici con 8 distrattori.
Logic

Logic 1

0

1

2

Logic 2 (era logic 3 nella skill map)

0

1

2

Logic 3 (era logic 2 nella skill map)

0

1

2

Visuo

Visuo 1

0

1

2

Visuo 2

0

1

2

Visuo 3

0

1

2

---
title: "Studio preliminare"
subtitle: "take II"
format: 
  html:
    page-layout: full
    toc: true
    toc-location: body
    code-tools:
      source: true
      toggle: false
      caption: Guarda il codice
theme: cosmo
editor_options: 
  chunk_output_type: console
---

```{r}
#| warning: false
#| message: false
#| echo: false
library(ggplot2)
library(psych)
library(TAM)
library(knitr)
library(patchwork)
library(lavaan)

set.seed(999)
knitr::opts_chunk$set(echo=FALSE,  
                      eval=TRUE,  
                      warning = FALSE, 
                      message = FALSE, 
                      fig.align = "center")
knitr::knit_hooks$set(purl = knitr::hook_purl)

rm(list = ls())
select.dist = function(dist.list, selection) {
resp = list()
for (i in 1:length(selection)) {
resp[[i]] = dist.list[[selection[i]]]
names(resp)[[i]] = selection[i]
}
return(resp)
}

source("Shapes_list-10-11-Ottavia.R")
source("Class and Methods v02.R")
source("Rules_27102022.R")
source("DrawRegPolygon.R")
source("CodiceDistrattoriVero.R")

draws<- function(obj, main = NULL, canvas = TRUE, bg = "white",mar=c(1,1,1,1),xlim=16,by=1.5) {
library(DescTools)
if (canvas == TRUE)
{
Canvas(xlim=xlim,mar=mar, main = main, bg = bg)
}
for(j in 1:length(obj$shape))
{
if(obj$visible[[j]]==1)
{
if(obj$num[[j]][1]==1){
if(grepl("line",obj$shade[[j]][1]))
{
elements<-decof(obj)
plotting_lines<-which(obj$visible==1 & grepl("line",unlist(obj$shade)))
for(ll in 1:length(plotting_lines)){
line(elements[[plotting_lines[[ll]]]],obj$shade[[j]][1],lwd=3,by=by) #Pejo tacon che sbrego

}
obj$shade[[j]][1] <- NA
}
DrawRegPolygon(x = obj$pos.x[[j]], y = obj$pos.y[[j]], rot = obj$rotation[[j]],
 radius.x = obj$size.x[[j]], radius.y = obj$size.y[[j]], nv = obj$nv[[j]],
 lty=obj$lty[[j]],lwd=obj$lwd[[j]],col = obj$shade[[j]])


}else{

DrawCircle(x = obj$pos.x[[j]], y = obj$pos.y[[j]],
 r.out = obj$size.x[[j]],r.in= obj$size.y[[j]], theta.1=obj$theta.1[[j]],
 theta.2=obj$theta.2[[j]], nv = obj$nv[[j]],
 lty=obj$lty[[j]],lwd=obj$lwd[[j]],col = obj$shade[[j]])

}
}
}
}

empty <- function() {
value <- list(
shape = "empty",
size.x = list(5),
size.y = list(5),
theta.1= list(0),
theta.2= list(0),
rotation = list(pi),
pos.x = list(0),
pos.y = list(0),
lty = list(0),
lwd = list(1),
num = list(1),
nv = list(101),
shade = list(NA),
visible = 0,
tag=list(c('simple'))
)
attr(value, "class") <- "field"
value
}

bow.tie.inv <- function(pos.x = 0) {
value <-cof(triangle(pos.x = pos.x+10, pos.y = pos.x, rot=pi/3, 
 s.x = 10, s.y=10), 
triangle(pos.x = pos.x-10, pos.y = pos.x, rot=-pi, 
 s.x = 10, s.y=10))
value$tag <- list("compose2","fill", "rotate")
attr(value, "class") <- "field"
value
}

lilth<-lily()
s.lilth<-s.lily()
for(i in 1:length(lilth$shape)) {
lilth$size.x[[i]] <-lilth$size.x[[i]]/2
lilth$size.y[[i]] <-lilth$size.y[[i]]/2
lilth$pos.y[[i]] <-lilth$pos.y[[i]]/2
lilth$pos.x[[i]] <-lilth$pos.x[[i]]/2

}

s.lilth$size.x[[1]] <-s.lilth$size.x[[1]]/2
s.lilth$size.y[[1]] <-s.lilth$size.y[[1]]/2
s.lilth$pos.y[[1]] <-s.lilth$pos.y[[1]]/2
s.lilth$pos.x[[1]] <-s.lilth$pos.x[[1]]/2

papillon = bow.tie()
u.papillon = u.bow.tie()


for(i in 1:length(papillon$shape)) {
papillon$size.x[[i]] <-papillon$size.x[[i]]/2
papillon$size.y[[i]] <-papillon$size.y[[i]]/2
papillon$pos.y[[i]] <-papillon$pos.y[[i]]/2
papillon$pos.x[[i]] <-papillon$pos.x[[i]]/2

}

u.papillon$size.x[[1]] <-u.papillon$size.x[[1]]/2
u.papillon$size.y[[1]] <-u.papillon$size.y[[1]]/2
u.papillon$pos.y[[1]] <-u.papillon$pos.y[[1]]/2
u.papillon$pos.x[[1]] <-u.papillon$pos.x[[1]]/2


thepie = pie.4()
u.thepie = u.pie.4()


for(i in 1:length(thepie$shape)) {
thepie$size.x[[i]] <-thepie$size.x[[i]]/2
thepie$size.y[[i]] <-thepie$size.y[[i]]/2
thepie$pos.y[[i]] <-thepie$pos.y[[i]]/2
thepie$pos.x[[i]] <-thepie$pos.x[[i]]/2

}

u.thepie$size.x[[1]] <-u.thepie$size.x[[1]]/2
u.thepie$size.y[[1]] <-u.thepie$size.y[[1]]/2
u.thepie$pos.y[[1]] <-u.thepie$pos.y[[1]]/2
u.thepie$pos.x[[1]] <-u.thepie$pos.x[[1]]/2

biscuit = star()
u.biscuit = u.star()


for(i in 1:length(biscuit$shape)) {
biscuit$size.x[[i]] <-biscuit$size.x[[i]]/2
biscuit$size.y[[i]] <-biscuit$size.y[[i]]/2
biscuit$pos.y[[i]] <-biscuit$pos.y[[i]]/2
biscuit$pos.x[[i]] <-biscuit$pos.x[[i]]/2

}

u.biscuit$size.x[[1]] <-u.biscuit$size.x[[1]]/2
u.biscuit$size.y[[1]] <-u.biscuit$size.y[[1]]/2
u.biscuit$pos.y[[1]] <-u.biscuit$pos.y[[1]]/2
u.biscuit$pos.x[[1]] <-u.biscuit$pos.x[[1]]/2


square4bis <- function(size.x = 15, size.y=15) {
value <-cof(hline(s.x = size.x, 
                  s.y = size.y, 
                  pos.y=-15),
            vline(s.x = size.x, 
                  s.y = size.y, 
                  pos.x=15),
hline(pos.y=15, s.x = size.x, 
                  s.y = size.y),vline(pos.x=-15, s.x = size.x, 
                  s.y = size.y))
value$tag <- list("compose4")
attr(value, "class") <- "field"
value
}


smallbow.tie.inv <- function(pos.x = 0,pos.y=0,shd=NA) {
value <-cof(triangle(pos.x = pos.x+5, pos.y = pos.y, rot=pi/3, 
 s.x = 5, s.y=5,shd = shd), 
triangle(pos.x = pos.x-5, pos.y = pos.y, rot=-pi, 
 s.x = 5, s.y=5,shd = shd))
value$tag <- list("compose2","fill", "rotate")
attr(value, "class") <- "field"
value
}


u.smallbow.tie.inv <- function(pos.x = 0,pos.y=0,shd=NA) {
value <-cof(triangle(pos.x = pos.x+5, pos.y = pos.y, rot=pi/3, 
 s.x = 5, s.y=5,shd = shd), 
triangle(pos.x = pos.x-5, pos.y = pos.y, rot=-pi, 
 s.x = 5, s.y=5,shd = shd), 
single = T, name = "u.smallbowtie.inv")
value$tag <- list("compose2","fill", "rotate")
attr(value, "class") <- "field"
value
}

bow.tie.inv <- function(pos.x = 0) {
value <-cof(triangle(pos.x = pos.x+10, pos.y = pos.x, rot=pi/3, 
 s.x = 10, s.y=10), 
triangle(pos.x = pos.x-10, pos.y = pos.x, rot=-pi, 
 s.x = 10, s.y=10))
value$tag <- list("compose2","fill", "rotate")
attr(value, "class") <- "field"
value
}




blu = "deepskyblue3"

l.r = 7
l.x = 10

rombo4.1 = cof(cof(diagline(s.x = l.x, pos.x = l.r, pos.y = l.r), 
         diagline.inv(s.x = l.x, pos.x = -l.r, pos.y = l.r), 
         diagline.inv(s.x = l.x, pos.x = l.r, pos.y = -l.r), 
         diagline(s.x = l.x, pos.x = -l.r, pos.y = -l.r)))

giallo = "gold"

rosso = "firebrick"

ninja = (cof(luck(shd = "black"), 
         rotation(luck(shd = "black"), 3)))


```


# Intro 

Sulla base dei risultati dello studio pilota dello studio preliminare, abbiamo deciso di portare aventi lo studio e quindi di sviluppare altre nuove matrici.

Per il momento, abbiamo deciso di: 

- eliminare la somministrazione delle Raven "originali" (studio per il futuro)

- Considerare 3 matrici logiche e 3 matrici visuo spaziali

Abbiamo dei dubbi circa il tipo di disegno che vogliamo implementare. Nello specifico, non sappiamo se mantenere un disegno within o spostarci su un disegno between, dove il fattore between è il numero di distrattori. 

[Qui](https://www.dropbox.com/scl/fi/a38eyoyx5pddve7o1qjx8/Diesgno-studio-distrattori.xlsx?dl=0&rlkey=dtij7eb0v5d6rnjqzr0cph9gq) trovate la skill map usata per generare gli stimoli che seguono. 

[Qui](https://ottaviae.github.io/qualtrics/accordoIII.html) trovate i risultati dello studio preliminare (Rasch). 

Di seguito riportiamo le coppie equivalenti di matrici con 8 distrattori. 

# Logic 

## Logic 1

::: {.grid}

::: {.g-col-4}
### 0
```{r}
# vincolo non tangente non deve toccare interno con esterno
a_logic1a<- logic_rules(Raven(square4bis()),"OR")

a_logic1b<-logic_rules(Raven(cof(size(bow.tie(), 2),
                                 size(bow.tie.inv(), 2))),"AND")

a_logic1 = com(a_logic1a, a_logic1b)

draw(a_logic1, hide = F) 




```


```{r}
dist.a_logic1 = responses(a_logic1)


sel.al1 = c("correct", "r.top", "r.left", 
            "wp.copy", "wp.matrix", 
            "d.union", 
            "ic.inc", 
            "ic.flip") 
resp.a_logic1 = select.dist(dist.a_logic1, sel.al1)
p = split.mat(a_logic1)

a = hide(a_logic1$Sq7, c(1,3,5))

resp.a_logic1$ic.flip = cof(resp.a_logic1$ic.inc, 
                            a)

resp.a_logic1$d.union = cof(size(bow.tie(), 2),
                                 size(bow.tie.inv(), 2), 
                            cross.dice())

draw.dist(resp.a_logic1, n.resp = 8)
```

:::

::: {.g-col-4}
### 1
```{r}
# gemella a1_logic1 ------

# a1_logic1a<- logic_rules(Raven(cof(vline(pos.x = 17, s.x = 15),
#                                   vline(pos.x = -17, s.x = 15 ),
#                                   hline(pos.y = 15, s.x=17),
#                                   hline(pos.y = -15, s.x=17))),"OR")

a1_logic1a<- logic_rules(Raven(rombo4.1),"OR")
petalo.su = cof(v.arc.left.up(), 
                v.arc.right.up(), 
                name="petalo.su", 
                single = T)
petalo.giu = cof(v.arc.left.down(), 
                v.arc.right.down(), 
                name="petalo.giu", 
                single = T)

petalo.sx = cof(h.arc.left.down(), 
                h.arc.left.up(), 
                name="petalo.sx", 
                single = T)
petalo.dx = cof(h.arc.right.down(), 
                h.arc.right.up(), 
                name="petalo.dx", 
                single = T)


a1_logic1b<-logic_rules(Raven(cof(petalo.giu, petalo.su, 
            petalo.sx, petalo.dx)),"AND")


a1_logic1 = com(a1_logic1a, a1_logic1b)

draw(a1_logic1, hide = F)

```


```{r}
dist.a1_logic1 = responses(a1_logic1)


sel.al11 = c("correct", "r.top", "r.left", 
            "wp.copy", "wp.matrix", 
            "d.union", 
            "ic.inc", 
            "ic.flip") 

resp.a1_logic1 = select.dist(dist.a1_logic1, sel.al11)
resp.a1_logic1$ic.flip = cof(resp.a1_logic1$ic.inc, petalo.su)
resp.a1_logic1$d.union = cof(cof(petalo.giu, petalo.su, 
            petalo.sx, petalo.dx), 
                            cross.dice())

draw.dist(resp.a1_logic1, n.resp = 8)
```

:::

::: {.g-col-4}

## 2 

```{r}
pos.x = 0
cost.x = 9
cost.y = 5

maxi = cof(luck(pos.x = pos.x+cost.x, pos.y = pos.x, rot=pi, 
 s.x = cost.x, s.y=cost.y), 
luck(pos.x = pos.x-cost.x, pos.y = pos.x, rot=-pi, 
 s.x = cost.x, s.y=cost.y), 
luck(pos.x = pos.x, pos.y = pos.x+cost.x, rot=-pi, 
 s.x = cost.y, s.y=cost.x),
luck(pos.x = pos.x, pos.y = pos.x-cost.x, rot=-pi, 
 s.x = cost.y, s.y=cost.x)) 



a2_logic1b = logic_rules(Raven(size(maxi, 2)),"OR")

a2_logic1a<- logic_rules(Raven(square4bis()),"AND")


a2_logic1 = com(a2_logic1a, a2_logic1b)




draw(a2_logic1)

```


```{r}
dist.a2_logic1 = responses(a2_logic1)


sel.al21 = c("correct", "r.top", "r.left", 
            "wp.copy", "wp.matrix", 
            "d.union", 
            "ic.inc", 
            "ic.flip") 

resp.a2_logic1 = select.dist(dist.a2_logic1, sel.al21)
p = split.mat(a2_logic1, cell = 3)
resp.a2_logic1$ic.flip = replace(dist.a2_logic1$correct, 
                                 1, 
                                 p$vline)
resp.a2_logic1$ic.inc = hide(resp.a2_logic1$correct, 
                             1)
resp.a2_logic1$d.union = cof(size(maxi, 2), cross.dice())
resp.a2_logic1$wp.matrix = cof(a2_logic1$Sq3, a2_logic1$Sq1)


draw.dist(resp.a2_logic1, n.resp = 8)
```


:::

:::

## Logic 2 (era logic 3 nella skill map)

::: {.grid}

::: {.g-col-4}
### 0
```{r}
# vincolo non tangente non deve toccare interno con esterno
# a_logic2a<- logic_rules(Raven(square4bis()),"OR")
# 
# a_logic2b<-logic_rules(Raven(cof((vline()), 
#                                  (hline()), 
#                                  (diagline()), 
#                                  (diagline.inv()))),"AND")
# 
# a_logic2 = com(a_logic2a, a_logic2b)
# 
# draw(a_logic2, hide = F) 


size.x = 15*sqrt(2)/2
size.y = 15*sqrt(2)/2

a_logic2a<- logic_rules(Raven(cof(hline(s.x = size.x, 
                  s.y = size.y, 
                  pos.y=-size.x),
            vline(s.x = size.x, 
                  s.y = size.y, 
                  pos.x=size.x),
hline(pos.y=size.x, s.x = size.x, 
                  s.y = size.y),
vline(pos.x=-size.x, s.x = size.x, 
                  s.y = size.y))),"OR")

a_logic2b<-logic_rules(Raven(cof(slice(shd = "grey", lty = 0), 
                                 rotation(slice(shd = "grey", lty = 0), 3), 
                                 rotation(slice(shd = "grey", lty = 0), 5), 
                                 rotation(slice(shd = "grey", lty = 0), 7))),"XOR")

a_logic2a1 = apply(Raven(st1 = dot()))
a_logic2 = com(a_logic2b,a_logic2a1, a_logic2a )

draw(a_logic2, hide = F) 



```


```{r}
dist.a_logic2 = responses(a_logic2)


sel.al3 = c("correct", "r.top", "r.left", 
            "wp.copy", "wp.matrix", 
            "d.union", 
            "ic.inc", 
            "ic.flip") 

resp.a_logic2 = select.dist(dist.a_logic2, sel.al3)
p = split.mat(a_logic2)
resp.a_logic2$ic.flip = replace(resp.a_logic2$correct, 
                                5, 
                                diagline.inv())

resp.a_logic2$d.union = cof(pie.4(shd = "grey"), 
                            dot())

resp.a_logic2$ic.inc = hide(resp.a_logic2$correct, 
                            3)

resp.a_logic2$ic.flip = cof( a_logic2$Sq7, 
                             resp.a_logic2$ic.inc 
                           )

resp.a_logic2$wp.matrix = cof(a_logic2$Sq3, 
                               a_logic2$Sq7)
draw.dist(resp.a_logic2, n.resp = 8)



```

:::

::: {.g-col-4}
### 1
```{r}
# gemella a1_logic1 ------

# a1_logic2a<- logic_rules(Raven(cof(vline(pos.x = 17, s.x = 15),
#                                   vline(pos.x = -17, s.x = 15 ),
#                                   hline(pos.y = 15, s.x=17),
#                                   hline(pos.y = -15, s.x=17))),"OR")
# 
# 
# 
# a1_logic2b<-logic_rules(Raven(cof(
#   s_vertical(), s_horizontal(), diagline.inv(), diagline()
# )),"AND")
# 
# 
# a1_logic2 = com(a1_logic2a, a1_logic2b)

size.x = 15*sqrt(2)/2
size.y = 15*sqrt(2)/2
d = 11
q.grigio = cof(square(s.x = d,
                                         s.y = d,
                                         pos.x = d*sqrt(2)/2,
                                         pos.y = d*sqrt(2)/2,
                                         shd="grey", lty = 0),
         square(s.x = d,
                                         s.y = d,
                                         pos.x = d*sqrt(2)/2,
                                        pos.y = -d*sqrt(2)/2,
                                        shd="grey", lty = 0),
          square(s.x = d,
                                         s.y = d,
                                        pos.x = -d*sqrt(2)/2,
                                        pos.y = -d*sqrt(2)/2,
                 shd = "grey", lty = 0),
         square(s.x = d,
                                         s.y = d,
                                         pos.x = -d*sqrt(2)/2,
                                        pos.y = d*sqrt(2)/2,
                shd = "grey",
                lty = 0)
         )
a1_logic2a = logic_rules(Raven(q.grigio), "XOR")

d.c = d*sqrt(2)
a1_logic2b<-logic_rules(Raven((cof(slice(s.x = d.c, 
                                         s.y = d.c, shd = "white"),
                                   rotation(slice(s.x = d.c, 
                                                  s.y = d.c, shd = "white"), 3),
                                   rotation(slice(s.x =d.c, 
                                                  s.y = d.c, shd = "white"), 5),
                                   rotation(slice(s.x=d.c, 
                                                  s.y = d.c, shd = "white"), 7)))),"OR")





a1_logic2a1 = apply(Raven(dot()))         

a1_logic2 = com(a1_logic2a,a1_logic2a1, a1_logic2b )
draw(a1_logic2, hide = F)

```


```{r}
q.grigio.bordi = cof(square(s.x = d,
                                         s.y = d,
                                         pos.x = d*sqrt(2)/2,
                                         pos.y = d*sqrt(2)/2,
                                         shd="grey"),
         square(s.x = d,
                                         s.y = d,
                                         pos.x = d*sqrt(2)/2,
                                        pos.y = -d*sqrt(2)/2,
                                        shd="grey"),
          square(s.x = d,
                                         s.y = d,
                                        pos.x = -d*sqrt(2)/2,
                                        pos.y = -d*sqrt(2)/2,
                 shd = "grey"),
         square(s.x = d,
                                         s.y = d,
                                         pos.x = -d*sqrt(2)/2,
                                        pos.y = d*sqrt(2)/2,
                shd = "grey")
         )
dist.a1_logic2 = responses(a1_logic2)


sel.al12 = c("correct", "r.top", "r.left",
            "wp.copy", "wp.matrix",
            "d.union",
            "ic.inc",
            "ic.flip")

resp.a1_logic2 = select.dist(dist.a1_logic2, sel.al12)
resp.a1_logic2$ic.inc = hide(resp.a1_logic2$correct, 3)
resp.a1_logic2$ic.flip = cof(square(s.x = d,
                                         s.y = d,
                                         pos.x = d*sqrt(2)/2,
                                         pos.y = d*sqrt(2)/2,
                                         shd="grey", lty = 0), resp.a1_logic2$ic.inc)
resp.a1_logic2$d.union = cof(q.grigio.bordi, 
                             dot())
resp.a1_logic2$wp.matrix = cof(a1_logic2$Sq3, 
                               a1_logic2$Sq7)

draw.dist(resp.a1_logic2, n.resp = 8)


```

:::

::: {.g-col-4}
### 2

```{r}
d = 10
a2_logic2a = logic_rules(Raven(cof(circle(s.x = d,
                                         s.y = d,
                                         pos.x = d*sqrt(2)/2,
                                         pos.y = d*sqrt(2)/2,
                                         shd="grey", lty = 0),
         circle(s.x = d,
                                         s.y = d,
                                         pos.x = d*sqrt(2)/2,
                                        pos.y = -d*sqrt(2)/2,
                                        shd="grey", lty = 0),
          circle(s.x = d,
                                         s.y = d,
                                        pos.x = -d*sqrt(2)/2,
                                        pos.y = -d*sqrt(2)/2,
                 shd = "grey", lty = 0),
         circle(s.x = d,
                                         s.y = d,
                                         pos.x = -d*sqrt(2)/2,
                                        pos.y = d*sqrt(2)/2,
                shd = "grey",
                lty = 0)
         )), "OR")

d.c = d*sqrt(2)
l.r = 7
l.x = 10

rombo4.1 = cof(cof(diagline(s.x = l.x, pos.x = l.r, pos.y = l.r), 
         diagline.inv(s.x = l.x, pos.x = -l.r, pos.y = l.r), 
         diagline.inv(s.x = l.x, pos.x = l.r, pos.y = -l.r), 
         diagline(s.x = l.x, pos.x = -l.r, pos.y = -l.r)))
a2_logic2b<-logic_rules(Raven(rombo4.1),"XOR")




a2_logic2a1 = apply(Raven(dot()))         

a2_logic2 = com(a2_logic2a, a2_logic2b, a2_logic2a1)
draw(a2_logic2, hide = F)

```

```{r}
dist.a2_logic2 = responses(a2_logic2)


sel.al22 = c("correct", "r.top", "r.left",
            "wp.copy", "wp.matrix",
            "d.union",
            "ic.inc",
            "ic.flip")

resp.a2_logic2 = select.dist(dist.a2_logic2, sel.al22)
resp.a2_logic2$ic.inc = hide(resp.a2_logic2$correct, 7)

resp.a2_logic2$ic.flip = cof(resp.a2_logic2$ic.inc, 
                               diagline(s.x = l.x, pos.x = -l.r, pos.y = -l.r))
resp.a2_logic2$d.union = cof(cof(circle(s.x = d,
                                         s.y = d,
                                         pos.x = d*sqrt(2)/2,
                                         pos.y = d*sqrt(2)/2,
                                         shd="grey", lty = 1),
         circle(s.x = d,
                                         s.y = d,
                                         pos.x = d*sqrt(2)/2,
                                        pos.y = -d*sqrt(2)/2,
                                        shd="grey", lty = 1),
          circle(s.x = d,
                                         s.y = d,
                                        pos.x = -d*sqrt(2)/2,
                                        pos.y = -d*sqrt(2)/2,
                 shd = "grey", lty = 1),
         circle(s.x = d,
                                         s.y = d,
                                         pos.x = -d*sqrt(2)/2,
                                        pos.y = d*sqrt(2)/2,
                shd = "grey",
                lty = 1)
         ), dot())
p = split.mat(a2_logic2, cell = 7)
# resp.a2_logic2$wp.matrix = cof(hide(a2_logic2$Sq3, 9), 
#                                p[[1]], p[[2]], 
#                                p[[3]])
resp.a2_logic2$wp.matrix = cof(a2_logic2$Sq7,
                               a2_logic2$Sq3)



draw.dist(resp.a2_logic2, n.resp = 8)
```


:::

:::


## Logic 3 (era logic 2 nella skill map)

::: {.grid}

::: {.g-col-4}
### 0

```{r}
a_logic3a<-logic_rules(Raven(cof(hexagon(shd="line1"),
                                 hexagon(shd="line2"),empty(),
                                 e.hexagon())),"AND")

mcross<-cof(size(bow.tie(), 2),size(bow.tie.inv(), 2))

# a_logic3a<-logic_rules(Raven(q.grigio),"AND")

a_logic3b<-logic_rules(Raven(mcross),"XOR")

#a_logic3c<-apply(Raven(square(s.x = d*2+1.5, s.y=d*2+1.5 )))
a_logic3 = com(a_logic3a, a_logic3b)

draw(a_logic3, hide =F)

```


```{r}
dist.a_logic3 = responses(a_logic3)

sel.al3 = c("correct", "r.diag", "r.left", 
            "wp.copy", "wp.matrix", 
            "d.union", 
            "ic.inc", 
            "ic.flip") 

resp.a_logic3 = select.dist(dist.a_logic3, sel.al3)
p = split.mat(a_logic3, cell = 3)
resp.a_logic3$ic.flip = cof(resp.a_logic3$ic.inc, reflection(p$triangle, 2))

resp.a_logic3$d.union = cof(a_logic3$Sq1, 
                            luck(s.x = 17))
resp.a_logic3$wp.matrix = cof(a_logic3$Sq4, 
                              mcross)

draw.dist(resp.a_logic3, n.resp = 8)



```


:::

::: {.g-col-4}
### 1

```{r}
a1_logic3a<-logic_rules(Raven(cof(pentagon(shd="line2"),
                                 pentagon(shd="line1"),empty(),
                                 pentagon())),"AND")

a1_logic3b<-logic_rules(Raven((cof(petalo.giu, petalo.su, 
            petalo.sx, petalo.dx))),"XOR")

a1_logic3 = com(a1_logic3a, a1_logic3b)



draw(a1_logic3, hide =F)
```


```{r}
dist.a1_logic3 = responses(a1_logic3)

sel.al12 = c("correct", "r.diag", "r.left", 
            "wp.copy", "wp.matrix", 
            "d.union", 
            "ic.inc", 
            "ic.flip") 

resp.a1_logic3 = select.dist(dist.a1_logic3, sel.al3)
resp.a1_logic3$ic.flip = cof(resp.a1_logic3$ic.inc, 
                             petalo.dx)

resp.a1_logic3$d.union = cof(a1_logic3$Sq3, 
                            circle(s.x = 12, s.y = 12))
resp.a1_logic3$wp.matrix = cof(a1_logic3$Sq4, petalo.dx, petalo.sx)
resp.a1_logic3$wp.copy = a1_logic3$Sq1
draw.dist(resp.a1_logic3, n.resp = 8)



```

:::

::: {.g-col-4}

### 2

```{r}
# a2_logic3a<-logic_rules(Raven(cof(hexagon(shd="line1", lty = 0),
#                                  hexagon(shd="line2", lty = 0),
#                                  dot(),e.hexagon())),"XOR")

#d.cerchio = 16
# a2_logic3a1<-apply(Raven(
#   st1=square(s.x = d.cerchio, s.y=d.cerchio)
# ))
# raggio = d.cerchio/2
# 
# 
# 
# a2_logic3a = logic_rules(Raven(cof(square(s.x = raggio *sqrt(2), 
#                                          s.y = raggio *sqrt(2), 
#                                          pos.x = (raggio*(pi/2))/2, 
#                                          pos.y = (raggio*(pi/2))/2,
#                                          shd="grey", lty = 0), 
#          square(s.x = raggio *sqrt(2), 
#                                          s.y = raggio *sqrt(2), 
#                                          pos.x = (raggio*(pi/2))/2, 
#                                         pos.y = -(raggio*(pi/2))/2,
#                                         shd="grey", lty = 0), 
#           square(s.x = raggio *sqrt(2), 
#                                          s.y = raggio *sqrt(2),  
#                                         pos.x = -(raggio*(pi/2))/2, 
#                                         pos.y = -(raggio*(pi/2))/2, 
#                  shd = "grey", lty = 0), 
#          square(s.x = raggio *sqrt(2), 
#                                          s.y = raggio *sqrt(2), 
#                                          pos.x = -(raggio*(pi/2))/2, 
#                                         pos.y = (raggio*(pi/2))/2, 
#                 shd = "grey", 
#                 lty = 0))), "XOR")
# 
# 
# a2_logic3b<-logic_rules(Raven((cof(slice(s.x = 10), 
#                                    rotation(slice(s.x = 10), 3), 
#                                    rotation(slice(s.x = 10), 5), 
#                                    rotation(slice(s.x = 10), 7)))),"AND")



# a2_logic3a1 = apply(Raven(
#   st1 = circle(s.x =15, s.y =15)
# ))
# 
# a2_logic3a = logic_rules(Raven(cof(slice(shd="grey", lty = 0), 
#          rotation(slice(shd="grey", lty = 0), 3), 
#          rotation(slice(shd="grey", lty = 0), 5), 
#          rotation(slice(shd="grey", lty = 0), 7))), "XOR")
# 
# a2_logic3b = logic_rules(Raven(size(maxi, 2)), "AND")
# 
# a2_logic3 = com(a2_logic3a, a2_logic3a1,  a2_logic3b)
# 
# draw(a2_logic3, hide =F)

maxi = cof(luck(pos.x = pos.x+cost.x, pos.y = pos.x, rot=pi, 
 s.x = cost.x, s.y=cost.y, shd = "white"), 
luck(pos.x = pos.x-cost.x, pos.y = pos.x, rot=-pi, 
 s.x = cost.x, s.y=cost.y, shd = "white"), 
luck(pos.x = pos.x, pos.y = pos.x+cost.x, rot=-pi, 
 s.x = cost.y, s.y=cost.x, shd = "white"),
luck(pos.x = pos.x, pos.y = pos.x-cost.x, rot=-pi, 
 s.x = cost.y, s.y=cost.x, shd = "white")) 
rect.x = 16
rect.y =12
a2_logic3a1 = apply(Raven(
  st1 = rectangle(s.x=rect.x, s.y = rect.y)
))

a2_logic3a = logic_rules(Raven(
  cof(rectangle(s.x=rect.x/2, s.y = rect.y/2, pos.x = rect.x/2, 
                pos.y = +rect.y/2, lty =0, 
               shd = "line12"),
rectangle(s.x=rect.x/2, s.y = rect.y/2, pos.x = rect.x/2, 
          pos.y = -rect.y/2,  lty =0, 
               shd = "line12"),
rectangle(s.x=rect.x/2, s.y = rect.y/2, pos.x = -rect.x/2, 
          pos.y = -rect.y/2, lty =0, 
               shd = "line12"),
rectangle(s.x=rect.x/2, s.y = rect.y/2, pos.x = -rect.x/2, 
          pos.y = rect.y/2, lty =0, 
               shd = "line12")
)

), "XOR")

maxi.h = cof(luck(pos.x = pos.x+cost.x, pos.y = pos.x, rot=pi, 
 s.x = cost.x, s.y=cost.y), 
luck(pos.x = pos.x-cost.x, pos.y = pos.x, rot=-pi, 
 s.x = cost.x, s.y=cost.y), single =T, name = "maxi.h")

maxi.v = cof(luck(pos.x = pos.x, pos.y = pos.x+cost.x, rot=-pi, 
 s.x = cost.y, s.y=cost.x),
luck(pos.x = pos.x, pos.y = pos.x-cost.x, rot=-pi, 
 s.x = cost.y, s.y=cost.x), single = T,
name = "maxi.v")




a2_logic3b = logic_rules(Raven(cof(size(maxi.v, 2), 
                                   size(maxi.h, 2), 
                                   empty(), 
                                   empty())), "AND")

a2_logic3 = com(a2_logic3a, a2_logic3a1,  a2_logic3b)

draw(a2_logic3, hide =F)

```


```{r}
dist.a2_logic3 = responses(a2_logic3)

sel.al23 = c("correct", "r.diag", "r.left", 
            "wp.copy", "wp.matrix", 
            "d.union", 
            "ic.inc", 
            "ic.flip") 

resp.a2_logic3 = select.dist(dist.a2_logic3, sel.al23)
# resp.a1_logic3$ic.flip = cof(resp.a1_logic3$ic.inc, 
#                              petalo.dx)
# 
# resp.a1_logic3$d.union = cof(a1_logic3$Sq5, 
#                             circle(s.x = 12, s.y = 12))

resp.a2_logic3$ic.flip = cof(resp.a2_logic3$ic.inc,
                             size(maxi.h, 2))

resp.a2_logic3$wp.matrix = cof(rectangle(s.x=rect.x, s.y = rect.y, 
                                         shd = "line12"), 
                               size(maxi.v, 2))

resp.a2_logic3$d.union = cof(a2_logic3$Sq3, 
                             ellipse(s.y = 15))

draw.dist(resp.a2_logic3, n.resp = 8)



```


:::

:::


# Visuo 

## Visuo 1

::: {.grid}

::: {.g-col-4}
### 0

```{r}
a_visuo1c <-apply(Raven(cof(circle(s.x = 3,s.y = 3, shd = "white"),
                            square(s.x = 3,s.y = 3, shd = "white")),"trans.fill"))
a_visuo1a<-apply(Raven(cof(pentagon(),e.hexagon(),
                           circle(s.x = 15, s.y = 15)),
                       c("diff_shapes"),
                       c("diff_shapes.inv")))
coso = size(cof(slice(), rotation(slice(), 5), 
           name = "coso", single = T), 2)
a_visuo1b<-apply(Raven(coso, 
                       hrule = "rotation", 
                       vrule = "rotation.inv"))

a_visuo1 = com(a_visuo1a, a_visuo1b, a_visuo1c)

draw(a_visuo1, hide = F)
```

```{r}
dist.a_visuo1 = responses(a_visuo1)

sel.av1 = c("correct", "r.top", "r.left", 
            "wp.copy", "wp.matrix", 
            "d.union", 
            "ic.flip", 
            "ic.neg") 

resp.a_visuo1 = select.dist(dist.a_visuo1, sel.av1)
p = split.mat(a_visuo1)

resp.a_visuo1$ic.flip = cof(p$pentagon, 
                            rotation(p$coso, 3), 
                            p$circle)

resp.a_visuo1$d.union = cof(resp.a_visuo1$r.left, 
                            size(pie.4(), 2))

resp.a_visuo1$wp.matrix = cof(a_visuo1$Sq1, 
                              a_visuo1$Sq3)


draw.dist(resp.a_visuo1, n.resp = 8)
```

:::

::: {.g-col-4}
### 1

```{r}
a1_visuo1c<-apply(Raven(cof(ellipse(s.x = 5,s.y = 4, shd = "white"),
                           luck(s.x = 5,s.y = 4, shd = "white")),
                        c("trans.fill.inv")))

a1_visuo1a<-apply(Raven(cof(e.hexagon(s.x = 17, s.y = 17), 
             
              pentagon(s.x = 17, s.y = 17), 
               square(s.x = 17, s.y = 17)),
                       c("diff_shapes"),
                       c("diff_shapes.inv")))

a1_visuo1b<-apply(Raven(u.pie.2.inv(size.x = 9), 
                       hrule = "rotation", 
                       vrule = "rotation.inv"))


a1_visuo1 = com(a1_visuo1a, a1_visuo1b, a1_visuo1c)
draw(a1_visuo1, hide = F)

```


```{r}
dist.a1_visuo1 = responses(a1_visuo1)

sel.av11 = c("correct", "r.top", "r.left", 
            "wp.copy", "wp.matrix", 
            "d.union", 
            "ic.flip", 
            "ic.neg") 

resp.a1_visuo1 = select.dist(dist.a1_visuo1, sel.av11)
p = split.mat(a1_visuo1)

resp.a1_visuo1$ic.flip = cof(p$e.hexagon, 
                            rotation(p$u.pie.2, 2), 
                            p$ellipse)

resp.a1_visuo1$d.union = cof(size(pie.4(),2), resp.a1_visuo1$r.left
                            )

resp.a1_visuo1$wp.matrix = cof(a1_visuo1$Sq3, 
                              pentagon(s.x = 16, s.y = 16))

draw.dist(resp.a1_visuo1, n.resp = 8)
```

:::

::: {.g-col-4}


### 2

```{r}
a2_visuo1a<-apply(Raven(cof(pentagon(),
                           e.hexagon()),
                        c("trans.fill")))

a2_visuo1c<-apply(Raven(cof(luck(s.x = 7, s.y = 5, shd = "white"),

              size(circle( shd = "white"), 3),
               square(s.x = 5, s.y = 5, shd = "white")),
                       c("diff_shapes"),
                       c("diff_shapes.inv")))

# a2_visuo1b<-apply(Raven(pacman(size.x = 10, shd = "white"),
#                        hrule = "rotation",
#                        vrule = "rotation.inv"))

baguette = cof(ellipse(s.x = 12, s.y = 7, shd = "white", 
                       rot = pi), 
         hline(s.x=12), single = T, name = "coso2")

a2_visuo1b<-apply(Raven(baguette,
                       hrule = "rotation",
                       vrule = "rotation.inv"))



a2_visuo1 = com(a2_visuo1a, a2_visuo1b, a2_visuo1c)
draw(a2_visuo1, hide = F)

```


```{r}
dist.a2_visuo1 = responses(a2_visuo1)

sel.av21 = c("correct", "r.top", "r.diag",
            "wp.copy", "wp.matrix",
            "d.union",
            "ic.flip",
            "ic.neg")

resp.a2_visuo1 = select.dist(dist.a2_visuo1, sel.av21)
p = split.mat(a2_visuo1)

resp.a2_visuo1$ic.flip = cof(p$pentagon,
                            rotation(p$coso2, 2),
                            p$luck)

p$pentagon$shade = "white"
resp.a2_visuo1$ic.neg = replace(resp.a2_visuo1$correct, 
                                1, 
                                p$pentagon)

resp.a2_visuo1$wp.matrix = cof(a2_visuo1$Sq3, 
                              e.hexagon(s.x = 16, s.y = 16))

resp.a2_visuo1$wp.copy = a2_visuo1$Sq2

resp.a2_visuo1$d.union = cof(e.hexagon(),
                            size(ninja, 2))

draw.dist(resp.a2_visuo1, n.resp = 8)
```

:::


:::

## Visuo 2


::: {.grid}

::: {.g-col-4}
### 0
```{r}
a_visuo2a = apply(Raven(
  st1 = cof(square(s.x =16, s.y = 16, shd = "grey", lty = 0), 
           
            ellipse(s.x = 15, s.y = 12,shd = "grey", lty = 0),
            e.hexagon(shd = "grey", lty = 0)), 
  hrule = "diff_shapes", 
  vrule = "diff_shapes"
))

a_visuo2b = apply(Raven(
  st1 = pacman(size.x = 10, shd = "white"), 
  vrule = c("rotation.inv"), 
  hrule = c("rotation")
))


a_visuo2c = apply(Raven(
  st1 = size(circle(shd = "black"), 2), 
  vrule = "size"
))


a_visuo2 = com(a_visuo2a, a_visuo2b, a_visuo2c)

draw(a_visuo2)




```


```{r}
dist.a_visuo2 = responses(a_visuo2)


sel.a_visuo2 = c("correct", "r.top", "r.diag", "wp.copy", 
            "wp.matrix" ,
            "d.union", 
            "ic.flip", # modifico pacman
            "ic.scale") 

resp.a_visuo2 = select.dist(dist.a_visuo2, 
                       sel.a_visuo2)

resp.a_visuo2$ic.flip = reflection(dist.a_visuo2$correct, 2)

resp.a_visuo2$ic.scale = cof(resp.a_visuo2$correct, 
                             size(circle(shd = "black"), 2))

p2 = split.mat(a_visuo2, cell = 2)
p1 = split.mat(a_visuo2, cell = 1)

resp.a_visuo2$wp.matrix = cof(p1$ellipse, 
                              p2$pacman, p2$circle)



draw.dist(resp.a_visuo2, n.resp = 8, main = T)
```


:::

::: {.g-col-4}
### 1
```{r}
biscotto = cof(hexagon(shd = "grey", lty = 0), 
              rot.hexagon(shd = "grey", lty = 0), 
              single = T, 
              name = "biscotto")

a1_visuo2a = apply(Raven(
  st1 = cof( pentagon(shd = "grey", lty = 0),
            biscotto, 
            square(s.x =16, s.y = 16, shd = "grey", lty = 0)), 
  hrule = "diff_shapes", 
  vrule = "diff_shapes"
))

a1_visuo2b = apply(Raven(
  st1 = slice(s.x = 11, shd = "white"), 
  vrule = c("rotation.inv"), 
  hrule = c("rotation")
))


a1_visuo2c = apply(Raven(
  st1 = size(circle(shd = "black"), 2), 
  vrule = "size"
))


a1_visuo2 = com(a1_visuo2a, a1_visuo2b, a1_visuo2c)

draw(a1_visuo2)



```


```{r}
dist.a1_visuo2 = responses(a1_visuo2)


sel.dist.a1_visuo2 = c("correct", "r.top", "r.diag", "wp.copy", 
            "wp.matrix" ,
            "d.union", 
            "ic.flip", # modifico pacman
            "ic.scale") 

resp.a1_visuo2 = select.dist(dist.a1_visuo2, 
                       sel.dist.a1_visuo2)

resp.a1_visuo2$ic.flip = reflection(dist.a1_visuo2$correct, 2)
resp.a1_visuo2$ic.scale = cof(resp.a1_visuo2$correct, 
                              size(circle(shd="black"), 2))

p2 = split.mat(a1_visuo2, cell = 2)
p1 = split.mat(a1_visuo2, cell = 1)

resp.a1_visuo2$wp.matrix = cof(p1$biscotto, 
                              p2$slice, p2$circle)

draw.dist(resp.a1_visuo2, n.resp = 8, main = T)
```

:::

::: {.g-col-4}

### 2

```{r}
a2_visuo2b = apply(Raven(
  st1 = cof( pentagon(shd = "white", lty = 1, s.x = 11, s.y = 11),
            ellipse(shd = "white", s.x = 11, s.y = 8), 
            square(s.x =11, s.y = 11, shd = "white", lty = 1)), 
  hrule = "diff_shapes", 
  vrule = "diff_shapes"
))

a2_visuo2a = apply(Raven(
  st1 = pacman( shd = "grey", size.x = 15, lty = 0), 
  vrule = c("rotation.inv"), 
  hrule = c("rotation")
))



a2_visuo2c = apply(Raven(
  st1 = size(ninja, 3), 
  vrule = "size"
))


a2_visuo2 = com(a2_visuo2a, a2_visuo2b,  a2_visuo2c)

draw(a2_visuo2)




```


```{r}
dist.a2_visuo2 = responses(a2_visuo2)


sel.dist.a2_visuo2 = c("correct", "r.top", "r.diag", "wp.copy",
            "wp.matrix" ,
            "d.union",
            "ic.flip", # modifico pacman
            "ic.scale")

resp.a2_visuo2 = select.dist(dist.a2_visuo2,
                       sel.dist.a2_visuo2)

resp.a2_visuo2$ic.flip = reflection(dist.a2_visuo2$correct, 2)

resp.a2_visuo2$ic.scale = cof(resp.a2_visuo2$correct, 
                              size(ninja, 2))

p2 = split.mat(a2_visuo2, cell = 2)
p1 = split.mat(a2_visuo2, cell = 1)

resp.a2_visuo2$wp.matrix = cof(p2$pacman, 
                               p1$ellipse, 
                               p1[[3]], p1[[4]])

draw.dist(resp.a2_visuo2, n.resp = 8, main = T)
```


:::

:::

## Visuo 3


::: {.grid}

::: {.g-col-4}
### 0
```{r}
a_3a = apply(
  Raven(
    st1 = cof(circle(s.x = 17, s.y = 17), 
              pentagon(s.x = 16, s.y = 16), 
              e.hexagon(s.x = 17, s.y = 17)), 
    vrule = c("diff_shapes"), 
    hrule = "diff_shapes"
  )
)

a_3b = apply(
  Raven(
    st1 = baguette, 
    vrule = c("rotation"), 
    hrule = "rotation"
  )
)


a_3c = apply(
  Raven(
    st1 = circle(s.x = 4, s.y = 4), 
    vrule = c("fill"), 
    hrule = "fill"
  )
)

a_3 = com(a_3a, a_3b, a_3c)
draw(a_3, hide = F)


```


```{r}
dist.a3 = responses(a_3, choose.copy = 1)


sel.a3 = c("correct", "r.top", "r.diag", 
           "wp.copy", "wp.matrix", "d.union", 
           "ic.neg", "ic.flip")


resp.a3 = select.dist(dist.a3, 
                      sel.a3)

resp.a3$d.union=cof(resp.a3$wp.copy, pie.4(s.x = 11))

p = split.mat(a_3)

resp.a3$ic.flip = replace(resp.a3$correct, 
                          4, 
                          rotation(p$coso2, 3))

draw.dist(resp.a3, n.resp = 8, main = T)
```


:::

::: {.g-col-4}
### 1

```{r}
a1_3a = apply(
  Raven(
    st1 = cof(e.hexagon(s.x = 17, s.y = 17), 
              square(s.x = 19, s.y = 19), 
              pentagon(s.x = 17, s.y = 17)), 
    vrule = c("diff_shapes"), 
    hrule = "diff_shapes"
  )
)

a1_3b = apply(
  Raven(
    st1 = pie.2(), 
    vrule = c("rotation"), 
    hrule = "rotation"
  )
)


a1_3c = apply(
  Raven(
    st1 = circle(s.x = 4, s.y = 4), 
    vrule = c("fill"), 
    hrule = "fill"
  )
)

a1_3 = com(a1_3a, a1_3b, a1_3c)
draw(a1_3, hide = F)



```


```{r}
dist.a13 = responses(a1_3, choose.copy = 1)


sel.a13 = c("correct", "r.top", "r.diag", 
           "wp.copy", "wp.matrix", "d.union", 
           "ic.neg", "ic.flip")


resp.a13 = select.dist(dist.a13, 
                      sel.a13)

p = split.mat(a1_3)

resp.a13$ic.flip = cof(p$pentagon, 
                       pie.2.inv(), 
                       p$circle)
resp.a13$d.union = cof(a1_3$Sq5, 
                       pie.4())

draw.dist(resp.a13, n.resp = 8, main = T)
```

:::

::: {.g-col-4}

### 2
```{r}
biscotto = cof(hexagon(shd = "black", lty = 0), 
              rot.hexagon(shd = "black", lty = 0), 
              single = T, 
              name = "biscotto")
ninja = (cof(luck(shd = "black"), 
         rotation(luck(shd = "black"), 3), 
         single = T, 
         name = "ninja"))
coso = size(cof(slice(shd = "white", s.x = 19), 
                rotation(slice(shd = "white", s.x = 19), 5), 
           name = "coso", single = T), 2)
a2_3a = apply(Raven(st1 = circle(s.x = 15, s.y=15), 
                        vrule = c("fill"), 
    hrule = "fill"))

a2_3b = apply(Raven(st1 = coso, 
                        vrule = c("rotation"), 
    hrule = "rotation"))



a2_3c = apply(
  Raven(
    st1 = cof(size(circle(shd="white"), 3), size(square(shd = "white"), 3), size(triangle(shd = "white"), 
                                                      3)), 
    vrule = c("diff_shapes"), 
    hrule = "diff_shapes"
  )
)



a2_3 = com(a2_3a, a2_3b, a2_3c)
draw(a2_3, hide = F)


```


```{r}
dist.a23 = responses(a2_3, choose.copy = 1)


sel.a23 = c("correct", "r.top", "r.diag",
           "wp.copy", "wp.matrix", "d.union",
           "ic.neg", "ic.flip")


resp.a23 = select.dist(dist.a23,
                      sel.a23)
p = split.mat(a2_3)
resp.a23$d.union = cof(rotation(a2_3$Sq3, 3), 
                       pie.4(s.x = 11))
resp.a23$ic.flip = replace(resp.a23$correct, 2, 
                          rotation(p$coso, 2))

resp.a23$ic.neg = replace(resp.a23$correct, 1, 
                          change.col(p$circle))


resp.a23$wp.matrix =cof(resp.a23$wp.copy, 
                        size(circle(shd= "white"), 3))

draw.dist(resp.a23, n.resp = 8, main = T)
```


:::

:::